diff --git a/rust/src/deferred.rs b/rust/src/deferred.rs
index 05d9e00912..082baa2429 100644
--- a/rust/src/deferred.rs
+++ b/rust/src/deferred.rs
@@ -18,7 +18,6 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use log::{debug, log_enabled, Level};
 use once_cell::sync::OnceCell;
 use pyo3::{
     create_exception, exceptions::PyException, exceptions::PyRuntimeError, intern, prelude::*,
@@ -26,7 +25,7 @@ use pyo3::{
 };
 use tokio::sync::oneshot;
 
-use crate::logging::context::{with_logcontext, DEBUG_LOGGER_NAME};
+use crate::logging::context::with_logcontext;
 use crate::tokio_runtime::runtime;
 
 create_exception!(
@@ -242,42 +241,9 @@ where
                 // Drive the awaitable in the captured logcontext. Restored here
                 // as we're on the reactor thread (the only thread where the
                 // context's `main_thread` check passes).
-                //
-                // Never re-start a context that has already finished. The
-                // request may have completed (or been cancelled;
-                // `create_deferred` does not propagate cancellation) while this
-                // task was still running. Restoring its context would log
-                // "Re-starting finished log context" and account our work
-                // against metrics that are already finalised, so such work runs
-                // in the sentinel instead. Both `__exit__` (which sets
-                // `finished`) and this check run on the reactor thread, so the
-                // check cannot race.
                 let context = match &logcontext {
-                    Some(handle) => {
-                        let finished = handle
-                            .logging_context()
-                            .is_some_and(|ctx| ctx.borrow(py).is_finished());
-                        if finished {
-                            if log_enabled!(target: DEBUG_LOGGER_NAME, Level::Debug) {
-                                // Only a real context can be finished, so
-                                // `logging_context()` is `Some` here.
-                                if let Some(ctx) = handle.logging_context() {
-                                    debug!(
-                                        target: DEBUG_LOGGER_NAME,
-                                        "run_python_awaitable: captured logcontext {} has \
-                                         finished; running in the sentinel",
-                                        ctx.bind(py).str()?
-                                    );
-                                }
-                            }
-                            None
-                        } else {
-                            handle.logging_context().map(|ctx| ctx.clone_ref(py))
-                        }
-                    }
-                    // Called from outside any scoped task: the sentinel. (The
-                    // reactor thread is normally at the sentinel already, in which
-                    // case the switch below is a no-op.)
+                    Some(handle) => handle.logging_context().map(|ctx| ctx.clone_ref(py)),
+                    // Called from outside any scoped task: the sentinel.
                     None => None,
                 };
 
diff --git a/rust/src/logging/context.rs b/rust/src/logging/context.rs
index 10f5d69dd4..3f80d972ed 100644
--- a/rust/src/logging/context.rs
+++ b/rust/src/logging/context.rs
@@ -703,11 +703,6 @@ impl LoggingContext {
 }
 
 impl LoggingContext {
-    /// Whether `__exit__` has run.
-    pub(crate) fn is_finished(&self) -> bool {
-        self.finished
-    }
-
     /// The context name as an owned Rust string.
     ///
     /// This copies the string data, so it is for error/debug paths only.