@@ -442,19 +442,28 @@ sdk::common::ExportResult ElasticsearchLogRecordExporter::Export(
   request->SetBody(body_vec);
 
 #ifdef ENABLE_ASYNC_EXPORT
+  bool rejected = false;
   // Send the request. Registration has to happen under the same lock Shutdown() takes to
   // flip is_shutdown_ and snapshot session_counter_ (see ForceFlush()) - otherwise a session
   // that passes the isShutdown() check above can still register after Shutdown() has already
   // taken its snapshot, and ForceFlush() would return without ever having waited for it.
   {
     std::lock_guard<std::recursive_mutex> lock_guard{synchronization_data_->force_flush_m};
-    if (isShutdown())
+    rejected = isShutdown();
+    if (!rejected)
     {
-      OTEL_INTERNAL_LOG_ERROR("[ES Log Exporter] Exporting "
-                              << records.size() << " log(s) failed, exporter is shutdown");
-      return sdk::common::ExportResult::kFailure;
+      synchronization_data_->session_counter_.fetch_add(1, std::memory_order_release);
     }
-    synchronization_data_->session_counter_.fetch_add(1, std::memory_order_release);
+  }
+
+  // Outside the lock: the client owns the session until somebody hands it back, and this is the
+  // only path that can, since the handler that would do it later is never built.
+  if (rejected)
+  {
+    session->FinishSession();
+    OTEL_INTERNAL_LOG_ERROR("[ES Log Exporter] Exporting "
+                            << records.size() << " log(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
   }
   std::size_t span_count    = records.size();
   auto synchronization_data = synchronization_data_;
 
@@ -19,10 +19,14 @@
 #include <gtest/gtest.h>
 #include <array>
 #include <chrono>
+#include <condition_variable>
 #include <cstddef>
 #include <cstdint>
+#include <mutex>
 #include <string>
+#include <thread>
 #include <utility>
+#include <vector>
 #include "nlohmann/json.hpp"
 
 namespace
@@ -106,6 +110,114 @@ class FakeSession final : public http_client::Session
   bool FinishSession() noexcept override { return true; }
 };
 
+// A client that owns what it creates, the way the curl client does: CreateSession() keeps a
+// reference in the client and only FinishSession() gives it back. CreateSession() also waits on
+// a gate, so a case can run Shutdown() while an export sits between its two shutdown checks.
+class RetainingSession final : public http_client::Session
+{
+public:
+  std::shared_ptr<http_client::Request> CreateRequest() noexcept override
+  {
+    return std::make_shared<FakeRequest>();
+  }
+
+  void SendRequest(std::shared_ptr<http_client::EventHandler>) noexcept override { sent_ = true; }
+
+  bool IsSessionActive() noexcept override { return finish_calls_ == 0; }
+  bool CancelSession() noexcept override { return true; }
+  // Counted rather than flagged: handing a session back twice is as wrong as not at all, and a
+  // flag reads the same either way.
+  bool FinishSession() noexcept override
+  {
+    ++finish_calls_;
+    return true;
+  }
+
+  bool sent_                = false;
+  std::size_t finish_calls_ = 0;
+};
+
+class RetainingHttpClient final : public http_client::HttpClient
+{
+public:
+  std::shared_ptr<http_client::Session> CreateSession(
+      opentelemetry::nostd::string_view) noexcept override
+  {
+    {
+      std::unique_lock<std::mutex> lock{gate_m_};
+      entered_ = true;
+      gate_cv_.notify_all();
+      gate_cv_.wait(lock, [this] { return released_; });
+    }
+    auto session = std::make_shared<RetainingSession>();
+    std::lock_guard<std::mutex> lock{sessions_m_};
+    sessions_.push_back(session);
+    return session;
+  }
+
+  bool CancelAllSessions() noexcept override { return true; }
+  bool FinishAllSessions() noexcept override { return true; }
+  void SetMaxSessionsPerConnection(std::size_t) noexcept override {}
+
+  void WaitUntilCreating()
+  {
+    std::unique_lock<std::mutex> lock{gate_m_};
+    gate_cv_.wait(lock, [this] { return entered_; });
+  }
+
+  void Release()
+  {
+    {
+      std::lock_guard<std::mutex> lock{gate_m_};
+      released_ = true;
+    }
+    gate_cv_.notify_all();
+  }
+
+  std::size_t Sent()
+  {
+    std::lock_guard<std::mutex> lock{sessions_m_};
+    std::size_t n = 0;
+    for (const auto &s : sessions_)
+    {
+      n += s->sent_ ? 1 : 0;
+    }
+    return n;
+  }
+
+  std::size_t FinishCalls()
+  {
+    std::lock_guard<std::mutex> lock{sessions_m_};
+    std::size_t n = 0;
+    for (const auto &s : sessions_)
+    {
+      n += s->finish_calls_;
+    }
+    return n;
+  }
+
+  // What the client is still holding that nobody handed back.
+  std::size_t Retained()
+  {
+    std::lock_guard<std::mutex> lock{sessions_m_};
+    std::size_t n = 0;
+    for (const auto &s : sessions_)
+    {
+      n += s->finish_calls_ == 0 ? 1 : 0;
+    }
+    return n;
+  }
+
+private:
+  std::mutex gate_m_;
+  std::condition_variable gate_cv_;
+  bool entered_  = false;
+  bool released_ = false;
+
+  std::mutex sessions_m_;
+  std::vector<std::shared_ptr<RetainingSession>> sessions_;
+};
+
 class FakeHttpClient final : public http_client::HttpClient
 {
 public:
@@ -269,6 +381,44 @@ TEST(ElasticsearchLogsExporterTests, ShutdownClampsWaitToCallerTimeoutWhenExport
 
 // Regression test: once Shutdown() has been called, any later Export() must fail rather than
 // silently trying to register a session against an exporter that is already tearing down.
+// The case is only meaningful where the second shutdown check exists, but it is registered in
+// both builds: gtest_add_tests reads the source, so a case behind #ifdef is still handed to CTest
+// in the build that does not compile it and reports a pass it never ran.
+TEST(ElasticsearchLogsExporterTests, ARejectedExportHandsItsSessionBack)
+{
+#ifndef ENABLE_ASYNC_EXPORT
+  GTEST_SKIP() << "the shutdown re-check this covers is compiled only with async export";
+#else
+  auto client = std::make_shared<RetainingHttpClient>();
+  logs_exporter::ElasticsearchExporterOptions options;
+  auto exporter = std::unique_ptr<sdklogs::LogRecordExporter>(
+      new logs_exporter::ElasticsearchLogRecordExporter(options, client));
+
+  auto record = exporter->MakeRecordable();
+  record->SetBody("a record the exporter will refuse");
+  std::array<std::unique_ptr<sdklogs::Recordable>, 1> batch = {std::move(record)};
+
+  auto result = opentelemetry::sdk::common::ExportResult::kSuccess;
+  std::thread exporting([&] {
+    result = exporter->Export(
+        nostd::span<std::unique_ptr<sdklogs::Recordable>>(batch.data(), batch.size()));
+  });
+
+  // Shutdown lands while the export is inside CreateSession, so it sees no registered session
+  // and returns, and the export then meets the second check on its way back.
+  client->WaitUntilCreating();
+  exporter->Shutdown();
+  client->Release();
+  exporting.join();
+
+  EXPECT_EQ(opentelemetry::sdk::common::ExportResult::kFailure, result);
+  EXPECT_EQ(0u, client->Sent()) << "a rejected export must not send";
+  EXPECT_EQ(0u, client->Retained())
+      << "the rejected session is still held by the client, so nothing will call FinishSession";
+  EXPECT_EQ(1u, client->FinishCalls()) << "handed back exactly once, not twice";
+#endif
+}
+
 TEST(ElasticsearchLogsExporterTests, ExportAfterShutdownFails)
 {
   logs_exporter::ElasticsearchExporterOptions options;