diff --git a/src/logging/WriterFrontend.cc b/src/logging/WriterFrontend.cc
index 9ed9f802d3..73cba2ff3a 100644
--- a/src/logging/WriterFrontend.cc
+++ b/src/logging/WriterFrontend.cc
@@ -141,8 +141,7 @@ void WriterFrontend::Stop()
 
 	if ( backend )
 		{
-		backend->PrepareStop();
-		backend->Stop();
+		backend->SignalStop();
 		backend = 0; // Thread manager will clean it up once it finishes.
 		}
 	}
diff --git a/src/threading/BasicThread.cc b/src/threading/BasicThread.cc
index b7ec094309..09b6e95d7a 100644
--- a/src/threading/BasicThread.cc
+++ b/src/threading/BasicThread.cc
@@ -117,20 +117,7 @@ void BasicThread::Start()
 	OnStart();
 	}
 
-void BasicThread::PrepareStop()
-	{
-	if ( ! started )
-		return;
-
-	if ( terminating )
-		return;
-
-	DBG_LOG(DBG_THREADING, "Preparing thread %s to terminate ...", name);
-
-	OnPrepareStop();
-	}
-
-void BasicThread::Stop()
+void BasicThread::SignalStop()
 	{
 	if ( ! started )
 		return;
@@ -140,7 +127,20 @@ void BasicThread::Stop()
 
 	DBG_LOG(DBG_THREADING, "Signaling thread %s to terminate ...", name);
 
-	OnStop();
+	OnSignalStop();
+	}
+
+void BasicThread::WaitForStop()
+	{
+	if ( ! started )
+		return;
+
+	if ( terminating )
+		return;
+
+	DBG_LOG(DBG_THREADING, "Waiting for thread %s to terminate ...", name);
+
+	OnWaitForStop();
 
 	terminating = true;
 	}
diff --git a/src/threading/BasicThread.h b/src/threading/BasicThread.h
index 100efe8851..cb0108219c 100644
--- a/src/threading/BasicThread.h
+++ b/src/threading/BasicThread.h
@@ -71,32 +71,33 @@ public:
 	void Start();
 
 	/**
-	 * Signals the thread to prepare for stopping. This must be called
-	 * before Stop() and allows the thread to trigger shutting down
-	 * without yet blocking for doing so.
+	 * Signals the thread to prepare for stopping, but doesn't block to
+	 * wait for that to happen. Use WaitForStop() for that.
 	 *
+	 * The method lets Terminating() now return true, it does however not
+	 * force the thread to terminate. It's up to the Run() method to to
+	 * query Terminating() and exit eventually.
+	 * 
 	 * Calling this method has no effect if Start() hasn't been executed
 	 * yet.
 	 *
 	 * Only Bro's main thread must call this method.
 	 */
-	void PrepareStop();
+	void SignalStop();
 
 	/**
-	 * Signals the thread to stop. The method lets Terminating() now
-	 * return true. It does however not force the thread to terminate.
-	 * It's up to the Run() method to to query Terminating() and exit
-	 * eventually.
+	 * Waits until a thread has stopped after receiving SignalStop().
 	 *
 	 * Calling this method has no effect if Start() hasn't been executed
-	 * yet.
+	 * yet. If this is executed without calling SignalStop() first,
+	 * results are undefined.
 	 *
 	 * Only Bro's main thread must call this method.
 	 */
-	void Stop();
+	void WaitForStop();
 
 	/**
-	 * Returns true if Stop() has been called.
+	 * Returns true if WaitForStop() has been called and finished.
 	 *
 	 * This method is safe to call from any thread.
 	 */
@@ -145,18 +146,19 @@ protected:
 	virtual void OnStart()	{}
 
 	/**
-	 * Executed with PrepareStop() (and before OnStop()). This is a hook
-	 * into preparing the thread for stopping. It will be called from
-	 * Bro's main thread before the thread has been signaled to stop.
+	 * Executed with SignalStop(). This is a hook into preparing the
+	 * thread for stopping. It will be called from Bro's main thread
+	 * before the thread has been signaled to stop.
 	 */
-	virtual void OnPrepareStop()	{}
+	virtual void OnSignalStop()	{}
 
 	/**
-	 * Executed with Stop() (and after OnPrepareStop()). This is a hook
-	 * into stopping the thread. It will be called from Bro's main thread
-	 * after the thread has been signaled to stop.
+	 * Executed with WaitForStop(). This is a hook into waiting for the
+	 * thread to stop. It must be overridden by derived classes and only
+	 * return once the thread has indeed finished processing. The method
+	 * will be called from Bro's main thread.
 	 */
-	virtual void OnStop()	{}
+	virtual void OnWaitForStop() = 0;
 
 	/**
 	 * Executed with Kill(). This is a hook into killing the thread.
diff --git a/src/threading/Manager.cc b/src/threading/Manager.cc
index 59eff4fd99..39a6bdce7d 100644
--- a/src/threading/Manager.cc
+++ b/src/threading/Manager.cc
@@ -32,10 +32,10 @@ void Manager::Terminate()
 	// Signal all to stop.
 
 	for ( all_thread_list::iterator i = all_threads.begin(); i != all_threads.end(); i++ )
-		(*i)->PrepareStop();
+		(*i)->SignalStop();
 
 	for ( all_thread_list::iterator i = all_threads.begin(); i != all_threads.end(); i++ )
-		(*i)->Stop();
+		(*i)->WaitForStop();
 
 	// Then join them all.
 	for ( all_thread_list::iterator i = all_threads.begin(); i != all_threads.end(); i++ )
@@ -141,7 +141,7 @@ void Manager::Process()
 			else
 				{
 				reporter->Error("%s failed, terminating thread", msg->Name());
-				t->Stop();
+				t->SignalStop();
 				}
 
 			delete msg;
diff --git a/src/threading/MsgThread.cc b/src/threading/MsgThread.cc
index 6c63c5a287..902ea36410 100644
--- a/src/threading/MsgThread.cc
+++ b/src/threading/MsgThread.cc
@@ -161,16 +161,16 @@ MsgThread::MsgThread() : BasicThread(), queue_in(this, 0), queue_out(0, this)
 // Set by Bro's main signal handler.
 extern int signal_val;
 
-void MsgThread::OnPrepareStop()
+void MsgThread::OnSignalStop()
 	{
 	if ( finished || Killed() )
 		return;
 
-	// Signal thread to terminate and wait until it has acknowledged.
+	// Signal thread to terminate.
 	SendIn(new FinishMessage(this, network_time), true);
 	}
 
-void MsgThread::OnStop()
+void MsgThread::OnWaitForStop()
 	{
 	int signal_count = 0;
 	int old_signal_val = signal_val;
diff --git a/src/threading/MsgThread.h b/src/threading/MsgThread.h
index d5e223d48f..4492320541 100644
--- a/src/threading/MsgThread.h
+++ b/src/threading/MsgThread.h
@@ -228,8 +228,8 @@ protected:
 	 *
 	 */
 	virtual void Run();
-	virtual void OnStop();
-	virtual void OnPrepareStop();
+	virtual void OnWaitForStop();
+	virtual void OnSignalStop();
 	virtual void OnKill();
 
 private: