diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,28 @@
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [2.6.1] - 2026-11-18
+
+### Fixed
+- **Headers no longer hold up the messages of other peers.** The loop that
+  routes peer messages waited for the chain to import each `headers` message.
+  On Bitcoin Cash that took 20 seconds per message, and in that time no
+  message of any peer reached the application: blocks and pongs piled up, and
+  Haskoin Store took peers that were delivering for stalled ones. The loop now
+  hands headers and inventory to the chain and goes on. The rest of the
+  handling of that message, publishing it to the application and counting it
+  as handled for the peer's back-pressure, runs when the chain is done with
+  it. Ping, pong and address messages go to the peer manager the same way.
+  The application now gets a peer's header message after the chain has its
+  headers, and other messages of the same peer may reach it before.
+- Requires haskoin-core 2.0.1, which connects Bitcoin Cash headers about 60
+  times as fast.
+
+### Added
+- `chainThen` and `peerMgrThen` run an action once the chain or the peer
+  manager has handled every message sent to it before, without waiting.
+- `peerMessageDoneSTM`: `peerMessageDone` in `STM`.
+
 
 ## [2.6.0] - 2026-11-15
 
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -392,7 +392,11 @@
 
 A peer may have at most 16 messages published and not yet handled by the node.
 Past that, the node stops reading its socket, so a fast peer fills its own TCP
-window instead of the node's memory. The node does not wait for your
+window instead of the node's memory. A header or inventory message counts as
+handled once the chain has dealt with it, and reaches your subscriber then. The
+node hands it to the chain and goes on with the messages of the other peers, so
+a peer that is still delivering blocks is never held up by the headers that
+another peer sent. The node does not wait for your
 subscriber, though: a subscription is an unbounded queue, and one that falls
 behind holds every event it has not read. Keep reading events, and hand slow
 work to another thread.
diff --git a/haskoin-node.cabal b/haskoin-node.cabal
--- a/haskoin-node.cabal
+++ b/haskoin-node.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           haskoin-node
-version:        2.6.0
+version:        2.6.1
 synopsis:       P2P library for Bitcoin and Bitcoin Cash
 description:    Connect to Bitcoin (BTC) and Bitcoin Cash (BCH) peers, keep them healthy, and
                 sync block headers into a RocksDB database. Blocks and transactions can be
@@ -68,7 +68,7 @@
     , conduit-extra ==1.3.*
     , containers >=0.6 && <0.8
     , fast-logger ==3.2.*
-    , haskoin-core >=2.0.0 && <2.1
+    , haskoin-core >=2.0.1 && <2.1
     , network >=3.1 && <3.3
     , nqe >=0.7.0 && <0.8
     , random >=1.2 && <1.4
diff --git a/src/Haskoin/Node.hs b/src/Haskoin/Node.hs
--- a/src/Haskoin/Node.hs
+++ b/src/Haskoin/Node.hs
@@ -138,6 +138,8 @@
 where
 
 import Control.Concurrent.Async (link, withAsync)
+import Control.Concurrent.STM (atomically)
+import Data.Functor ((<&>))
 import Data.Time.Clock (NominalDiffTime)
 import Database.RocksDB (ColumnFamily, DB)
 import Haskoin
@@ -226,6 +228,25 @@
 -- being disconnected. Inventory with blocks goes to the chain, which asks for
 -- headers if it does not know them.
 --
+-- This loop never waits for the chain. The chain can take seconds over a
+-- batch of headers, and a loop that waited for it held up the messages of
+-- every peer: blocks and pongs piled up behind the headers, and the
+-- application took peers that were delivering for stalled ones. A header or
+-- inventory message is instead handed to the chain with the rest of its
+-- handling, which runs when the chain is done with it (see 'chainThen'):
+-- it is published to the application then, and only then counts as handled
+-- for the peer's allowance. The backpressure still holds for the peer that
+-- sent it, the chain's mailbox holds at most 'maxPendingMessages' messages of
+-- each peer, and the messages of the other peers keep flowing. The chain
+-- handles its mailbox in order, so the headers of a peer are imported in the
+-- order they came. The application gets a header message only once the
+-- chain has its headers, so it can look them up; other messages of the same
+-- peer may reach it before.
+--
+-- Messages for the peer manager, which is quick, are handled the same way,
+-- except @version@ and @verack@: the loop waits for those, since whether the
+-- next message of that peer is taken depends on them.
+--
 -- Messages reach the application only from online peers, except @version@
 -- and @verack@, which are the handshake itself. Bitcoin Core ignores
 -- anything else a peer sends before the handshake is done, and so does the
@@ -238,37 +259,42 @@
   case event of
     PeerConnected p -> do
       chainPeerConnected ch p
-      forward event
+      atomically (forward event)
     PeerDisconnected p -> do
       chainPeerDisconnected ch p
-      forward event
+      atomically (forward event)
     PeerMessage p m -> do
+      ticklePeer mgr p
+      online <- isOnline p
+      let done
+            | handshake m || online = forward event >> peerMessageDoneSTM p
+            | otherwise = peerMessageDoneSTM p
+          now = atomically done
+          later f = f done
       case m of
         MVersion v ->
-          peerMgrVersion mgr p v >> peerMgrSync mgr
+          peerMgrVersion mgr p v >> peerMgrSync mgr >> now
         MVerAck ->
-          peerMgrVerAck mgr p >> peerMgrSync mgr
+          peerMgrVerAck mgr p >> peerMgrSync mgr >> now
         MPing (Ping n) ->
-          peerMgrPing mgr p n >> peerMgrSync mgr
+          peerMgrPing mgr p n >> later (peerMgrThen mgr)
         MPong (Pong n) ->
-          peerMgrPong mgr p n >> peerMgrSync mgr
-        MAddr (Addr ns) ->
-          whenOnline p $ peerMgrAddrs mgr p (map snd ns) >> peerMgrSync mgr
-        MHeaders (Headers hs) ->
-          whenOnline p $ chainHeaders ch p (map fst hs) >> chainSync ch
-        MInv (Inv ivs) -> case [BlockHash iv.invHash | iv <- ivs, isBlock iv] of
-          [] -> return ()
-          bhs -> whenOnline p $ chainBlocksAnnounced ch p bhs >> chainSync ch
-        _ -> return ()
-      ticklePeer mgr p
-      if handshake m then forward event else whenOnline p (forward event)
-      peerMessageDone p
+          peerMgrPong mgr p n >> later (peerMgrThen mgr)
+        MAddr (Addr ns)
+          | online -> peerMgrAddrs mgr p (map snd ns) >> later (peerMgrThen mgr)
+        MHeaders (Headers hs)
+          | online -> chainHeaders ch p (map fst hs) >> later (chainThen ch)
+        MInv (Inv ivs)
+          | online,
+            bhs@(_ : _) <- [BlockHash iv.invHash | iv <- ivs, isBlock iv] ->
+              chainBlocksAnnounced ch p bhs >> later (chainThen ch)
+        _ -> now
   where
-    forward event = publish (PeerEvent event) output
-    whenOnline p act =
-      getOnlinePeer mgr p >>= \case
-        Just o | o.online -> act
-        _ -> return ()
+    forward event = publishSTM (PeerEvent event) output
+    isOnline p =
+      getOnlinePeer mgr p <&> \case
+        Just o -> o.online
+        _ -> False
     isBlock iv = iv.invType `elem` [InvBlock, InvWitnessBlock]
     handshake = \case
       MVersion _ -> True
diff --git a/src/Haskoin/Node/Chain.hs b/src/Haskoin/Node/Chain.hs
--- a/src/Haskoin/Node/Chain.hs
+++ b/src/Haskoin/Node/Chain.hs
@@ -92,6 +92,7 @@
     chainHeaders,
     chainBlocksAnnounced,
     chainSync,
+    chainThen,
   )
 where
 
@@ -577,3 +578,13 @@
 -- | Wait until the chain process has handled every message sent to it before.
 chainSync :: Chain -> IO ()
 chainSync ch = ChainSyncMsg `query` ch.mailbox
+
+-- | Run an action once the chain process has handled every message sent to
+-- it before, without waiting for that. "Haskoin.Node" uses it to finish a
+-- peer's headers or inventory message only when the chain has dealt with it,
+-- so that the backpressure of that one peer holds while the messages of all
+-- the other peers keep flowing. 'chainSync' would block the caller for as
+-- long as the chain is busy, and the chain can be busy for seconds while it
+-- imports headers.
+chainThen :: Chain -> STM () -> IO ()
+chainThen ch act = ChainSyncMsg (const act) `send` ch.mailbox
diff --git a/src/Haskoin/Node/Peer.hs b/src/Haskoin/Node/Peer.hs
--- a/src/Haskoin/Node/Peer.hs
+++ b/src/Haskoin/Node/Peer.hs
@@ -69,6 +69,7 @@
     setBusy,
     setFree,
     peerMessageDone,
+    peerMessageDoneSTM,
     maxPendingMessages,
   )
 where
@@ -226,7 +227,11 @@
 -- | Tell the peer process that the node has finished handling one of the
 -- messages that it published, so that it may read another one.
 peerMessageDone :: Peer -> IO ()
-peerMessageDone p = atomically $ modifyTVar' p.pending (max 0 . subtract 1)
+peerMessageDone = atomically . peerMessageDoneSTM
+
+-- | 'peerMessageDone' in 'STM'.
+peerMessageDoneSTM :: Peer -> STM ()
+peerMessageDoneSTM p = modifyTVar' p.pending (max 0 . subtract 1)
 
 -- | Run peer process in current thread. The 'Peer' must be the one that
 -- 'wrapPeer' built with the mailbox of this inbox.
diff --git a/src/Haskoin/Node/PeerMgr.hs b/src/Haskoin/Node/PeerMgr.hs
--- a/src/Haskoin/Node/PeerMgr.hs
+++ b/src/Haskoin/Node/PeerMgr.hs
@@ -89,6 +89,7 @@
     peerMgrAddrs,
     peerMgrVerAck,
     peerMgrSync,
+    peerMgrThen,
     getPeers,
     getOnlinePeer,
     ticklePeer,
@@ -627,6 +628,12 @@
 -- | Wait until the peer manager has handled every message sent to it before.
 peerMgrSync :: PeerMgr -> IO ()
 peerMgrSync mgr = Sync `query` mgr.mailbox
+
+-- | Run an action once the peer manager has handled every message sent to it
+-- before, without waiting for that. The non-blocking form of 'peerMgrSync'
+-- (see 'Haskoin.Node.Chain.chainThen').
+peerMgrThen :: PeerMgr -> STM () -> IO ()
+peerMgrThen mgr act = Sync (const act) `send` mgr.mailbox
 
 -- | Median of a list, or 'Nothing' if it is empty.
 median :: (Ord a, Fractional a) => [a] -> Maybe a
