@@ -163,7 +163,8 @@ def on_disconnect_returned():
                 # an unexpected-drop callback, it was queued first and consumed this
                 # operation. Otherwise, complete the explicit disconnection path now.
                 logger.info("{}: MQTT disconnected".format(self.name))
-                self._handle_mqtt_disconnected()
+                self.send_event_up(pipeline_events_base.DisconnectedEvent())
+                self._complete_pending_connection_op_after_disconnect()
 
             try:
                 self.transport.disconnect(clear_inflight=op.hard)
@@ -294,7 +295,25 @@ def _on_mqtt_message_received(self, topic, payload):
     def _on_mqtt_connection_dropped(self, cause):
         """Handle a transport-reported unexpected connection loss."""
         logger.info("{}: MQTT connection dropped unexpectedly: {}".format(self.name, cause))
-        self._handle_mqtt_disconnected(cause)
+        self.send_event_up(pipeline_events_base.DisconnectedEvent())
+        try:
+            self._reconcile_mqtt_operation_tracking_after_connection_drop()
+
+            # Higher layers will see that we're disconnected and may reconnect as necessary.
+            error = transport_exceptions.ConnectionDroppedError("Unexpected disconnection")
+            error.__cause__ = cause
+            self.report_background_exception(error)
+        finally:
+            # Completion callbacks can synchronously start work on a replacement connection.
+            self._complete_pending_connection_op_after_disconnect(cause)
+
+    @pipeline_thread.runs_on_pipeline_thread
+    def _reconcile_mqtt_operation_tracking_after_connection_drop(self):
+        """Reconcile MQTT operation tracking with the connection recovery policy.
+
+        This cannot be encapsulated inside the MQTTTransport because it has to do with
+        connection_retry policy.
+        """
 
         # If there is no connection retry, complete tracked MQTT operations as cancelled so
         # they do not remain pending indefinitely.
@@ -317,25 +336,9 @@ def _on_mqtt_connection_dropped(self, cause):
             )
             self.transport._op_manager.stop_tracking_non_publish_operations()
 
-        # Higher layers will see that we're disconnected and may reconnect as necessary.
-        error = transport_exceptions.ConnectionDroppedError("Unexpected disconnection")
-        error.__cause__ = cause
-        self.report_background_exception(error)
-
     @pipeline_thread.runs_on_pipeline_thread
-    def _handle_mqtt_disconnected(self, cause=None):
-        """Apply disconnected-state effects on the pipeline thread.
-
-        Called after either an unexpected transport callback or a successful explicit disconnect.
-
-        :param Exception cause: The Exception that caused the disconnection, if any (optional)
-        """
-        # Send an event to tell other pipeline stages that we're disconnected. Do this before
-        # we do anything else (in case upper stages have any "are we connected" logic.)
-        # NOTE: Other stages rely on the fact that this occurs before any op that may be in
-        # progress is completed. Be careful with changing the order things occur here.
-        self.send_event_up(pipeline_events_base.DisconnectedEvent())
-
+    def _complete_pending_connection_op_after_disconnect(self, cause=None):
+        """Complete a pending connection operation after disconnection effects are applied."""
         if self._pending_connection_op:
 
             connection_op = self._pending_connection_op
 
@@ -945,9 +945,7 @@ def test_disconnect_op_completed(self, stage, arbitrary_exception, pending_conne
         assert pending_connection_op.completed
         assert pending_connection_op.error is None
 
-    @pytest.mark.it(
-        "Applies connection-drop handling after completing the pending DisconnectOperation"
-    )
+    @pytest.mark.it("Applies connection-drop handling with a pending DisconnectOperation")
     @pytest.mark.parametrize(
         "connection_retry",
         [
@@ -981,6 +979,50 @@ def test_connection_drop_handling(
         assert isinstance(background_exception, transport_exceptions.ConnectionDroppedError)
         assert background_exception.__cause__ is arbitrary_exception
 
+    @pytest.mark.it(
+        "Applies connection-drop handling before completing the pending DisconnectOperation"
+    )
+    @pytest.mark.parametrize(
+        "connection_retry, cleanup_method_name",
+        [
+            pytest.param(
+                False,
+                "complete_all_tracked_operations_as_cancelled",
+                id="Connection retry disabled",
+            ),
+            pytest.param(
+                True,
+                "stop_tracking_non_publish_operations",
+                id="Connection retry enabled",
+            ),
+        ],
+    )
+    def test_connection_drop_handling_order(
+        self,
+        stage,
+        arbitrary_exception,
+        connection_retry,
+        cleanup_method_name,
+    ):
+        call_order = []
+        stage.nucleus.pipeline_configuration.connection_retry = connection_retry
+        stage.send_event_up.side_effect = lambda event: call_order.append(type(event))
+        cleanup_method = getattr(stage.transport._op_manager, cleanup_method_name)
+        cleanup_method.side_effect = lambda: call_order.append(cleanup_method_name)
+        pending_connection_op = pipeline_ops_base.DisconnectOperation(
+            callback=lambda op, error: call_order.append(type(op))
+        )
+        stage._pending_connection_op = pending_connection_op
+
+        stage.transport.on_mqtt_connection_dropped_handler(arbitrary_exception)
+
+        assert call_order == [
+            pipeline_events_base.DisconnectedEvent,
+            cleanup_method_name,
+            pipeline_events_base.BackgroundExceptionEvent,
+            pipeline_ops_base.DisconnectOperation,
+        ]
+
 
 @pytest.mark.describe(
     "MQTTTransportStage - OCCURRENCE: MQTT connection dropped with pending ConnectOperation"
 
@@ -10,7 +10,6 @@
 import time
 import urllib
 import sys
-import warnings
 from azure.iot.device.iothub import IoTHubDeviceClient, IoTHubModuleClient
 from azure.iot.device import exceptions as client_exceptions
 from azure.iot.device.common.auth import sastoken as st
@@ -1455,16 +1454,6 @@ def test_sets_on_c2d_message_received_handler_in_pipeline(
             client._mqtt_pipeline.on_c2d_message_received == client._inbox_manager.route_c2d_message
         )
 
-    @pytest.mark.it("Constructs a public client without Paho callback API deprecation warnings")
-    def test_no_paho_callback_api_deprecation_warning(self):
-        with warnings.catch_warnings():
-            warnings.simplefilter("error", DeprecationWarning)
-            client = IoTHubDeviceClient.create_from_connection_string(
-                "HostName=hostname.azure-devices.net;DeviceId=MyDevice;SharedAccessKey=Zm9vYmFy"
-            )
-
-        client.shutdown()
-
 
 @pytest.mark.describe("IoTHubDeviceClient (Synchronous) - .create_from_connection_string()")
 class TestIoTHubDeviceClientCreateFromConnectionString(