diff --git a/api/task_queue/task_queue_test.cc b/api/task_queue/task_queue_test.cc
index 3f638b7c69..a8a799f11b 100644
--- a/api/task_queue/task_queue_test.cc
+++ b/api/task_queue/task_queue_test.cc
@@ -37,11 +37,9 @@ TEST_P(TaskQueueTest, PostAndCheckCurrent) {
   rtc::Event event;
   auto queue = CreateTaskQueue(factory, "PostAndCheckCurrent");
 
-  // We're not running a task, so |queue| shouldn't be current.
-  // Note that because rtc::Thread also supports the TQ interface and
-  // TestMainImpl::Init wraps the main test thread (bugs.webrtc.org/9714), that
-  // means that TaskQueueBase::Current() will still return a valid value.
+  // We're not running a task, so there shouldn't be a current queue.
   EXPECT_FALSE(queue->IsCurrent());
+  EXPECT_FALSE(TaskQueueBase::Current());
 
   queue->PostTask(ToQueuedTask([&event, &queue] {
     EXPECT_TRUE(queue->IsCurrent());
diff --git a/rtc_base/thread.cc b/rtc_base/thread.cc
index 5e48e4b857..0fb2e813e0 100644
--- a/rtc_base/thread.cc
+++ b/rtc_base/thread.cc
@@ -296,21 +296,6 @@ void ThreadManager::SetCurrentThread(Thread* thread) {
     RTC_DLOG(LS_ERROR) << "SetCurrentThread: Overwriting an existing value?";
   }
 #endif  // RTC_DLOG_IS_ON
-
-  if (thread) {
-    thread->EnsureIsCurrentTaskQueue();
-  } else {
-    Thread* current = CurrentThread();
-    if (current) {
-      // The current thread is being cleared, e.g. as a result of
-      // UnwrapCurrent() being called or when a thread is being stopped
-      // (see PreRun()). This signals that the Thread instance is being detached
-      // from the thread, which also means that TaskQueue::Current() must not
-      // return a pointer to the Thread instance.
-      current->ClearCurrentTaskQueue();
-    }
-  }
-
   SetCurrentThreadInternal(thread);
 }
 
@@ -839,6 +824,7 @@ void* Thread::PreRun(void* pv) {
   Thread* thread = static_cast<Thread*>(pv);
   ThreadManager::Instance()->SetCurrentThread(thread);
   rtc::SetCurrentThreadName(thread->name_.c_str());
+  CurrentTaskQueueSetter set_current_task_queue(thread);
 #if defined(WEBRTC_MAC)
   ScopedAutoReleasePool pool;
 #endif
@@ -949,17 +935,6 @@ void Thread::InvokeInternal(const Location& posted_from,
   Send(posted_from, &handler);
 }
 
-// Called by the ThreadManager when being set as the current thread.
-void Thread::EnsureIsCurrentTaskQueue() {
-  task_queue_registration_ =
-      std::make_unique<TaskQueueBase::CurrentTaskQueueSetter>(this);
-}
-
-// Called by the ThreadManager when being set as the current thread.
-void Thread::ClearCurrentTaskQueue() {
-  task_queue_registration_.reset();
-}
-
 void Thread::QueuedTaskHandler::OnMessage(Message* msg) {
   RTC_DCHECK(msg);
   auto* data = static_cast<ScopedMessageData<webrtc::QueuedTask>*>(msg->pdata);
diff --git a/rtc_base/thread.h b/rtc_base/thread.h
index e25ed4ea8c..74aab623c8 100644
--- a/rtc_base/thread.h
+++ b/rtc_base/thread.h
@@ -551,12 +551,6 @@ class RTC_LOCKABLE RTC_EXPORT Thread : public webrtc::TaskQueueBase {
   void InvokeInternal(const Location& posted_from,
                       rtc::FunctionView<void()> functor);
 
-  // Called by the ThreadManager when being set as the current thread.
-  void EnsureIsCurrentTaskQueue();
-
-  // Called by the ThreadManager when being unset as the current thread.
-  void ClearCurrentTaskQueue();
-
   // Returns a static-lifetime MessageHandler which runs message with
   // MessageLikeTask payload data.
   static MessageHandler* GetPostTaskMessageHandler();
@@ -601,8 +595,6 @@ class RTC_LOCKABLE RTC_EXPORT Thread : public webrtc::TaskQueueBase {
 
   // Runs webrtc::QueuedTask posted to the Thread.
   QueuedTaskHandler queued_task_handler_;
-  std::unique_ptr<TaskQueueBase::CurrentTaskQueueSetter>
-      task_queue_registration_;
 
   friend class ThreadManager;
 
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index e1011f4119..d53a387914 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -1148,18 +1148,6 @@ TEST(ThreadPostDelayedTaskTest, InvokesInDelayOrder) {
   EXPECT_TRUE(fourth.Wait(0));
 }
 
-TEST(ThreadPostDelayedTaskTest, IsCurrentTaskQueue) {
-  auto current_tq = webrtc::TaskQueueBase::Current();
-  {
-    std::unique_ptr<rtc::Thread> thread(rtc::Thread::Create());
-    thread->WrapCurrent();
-    EXPECT_EQ(webrtc::TaskQueueBase::Current(),
-              static_cast<webrtc::TaskQueueBase*>(thread.get()));
-    thread->UnwrapCurrent();
-  }
-  EXPECT_EQ(webrtc::TaskQueueBase::Current(), current_tq);
-}
-
 class ThreadFactory : public webrtc::TaskQueueFactory {
  public:
   std::unique_ptr<webrtc::TaskQueueBase, webrtc::TaskQueueDeleter>
diff --git a/test/run_loop_unittest.cc b/test/run_loop_unittest.cc
index 160aba0716..a356cc265a 100644
--- a/test/run_loop_unittest.cc
+++ b/test/run_loop_unittest.cc
@@ -17,6 +17,7 @@
 namespace webrtc {
 
 TEST(RunLoopTest, TaskQueueOnThread) {
+  EXPECT_EQ(TaskQueueBase::Current(), nullptr);
   test::RunLoop loop;
   EXPECT_EQ(TaskQueueBase::Current(), loop.task_queue());
   EXPECT_TRUE(loop.task_queue()->IsCurrent());