diff --git a/p2p/p2p-test-utils/src/lib.rs b/p2p/p2p-test-utils/src/lib.rs
index da94327676..ed2a08f7ce 100644
--- a/p2p/p2p-test-utils/src/lib.rs
+++ b/p2p/p2p-test-utils/src/lib.rs
@@ -31,6 +31,7 @@ use logging::log;
 use mempool::{MempoolConfig, MempoolHandle};
 use subsystem::{ManagerJoinHandle, ShutdownTrigger};
 use test_utils::mock_time_getter::mocked_time_getter_milliseconds;
+use tokio::sync::mpsc;
 use utils::atomics::SeqCstAtomicU64;
 
 use crate::panic_handling::get_panic_notification;
@@ -219,3 +220,15 @@ macro_rules! expect_no_recv {
         $crate::expect_no_future_val!($receiver.recv())
     };
 }
+
+pub async fn wait_for_recv<T: Eq>(receiver: &mut mpsc::UnboundedReceiver<T>, value: &T) {
+    let wait_loop = async {
+        loop {
+            if receiver.recv().await.unwrap() == *value {
+                break;
+            }
+        }
+    };
+
+    expect_future_val!(wait_loop);
+}
diff --git a/p2p/src/peer_manager/mod.rs b/p2p/src/peer_manager/mod.rs
index 587bcc8461..5298443fe1 100644
--- a/p2p/src/peer_manager/mod.rs
+++ b/p2p/src/peer_manager/mod.rs
@@ -66,6 +66,7 @@ use crate::{
         ConnectivityService, NetworkingService,
     },
     peer_manager_event::PeerDisconnectionDbAction,
+    sync::sync_status::PeerBlockSyncStatus,
     types::{
         peer_address::{PeerAddress, PeerAddressIp4, PeerAddressIp6},
         peer_id::PeerId,
@@ -833,6 +834,7 @@ where
         if let Some(peer_id) = peers_eviction::select_for_eviction_block_relay(
             self.eviction_candidates(PeerRole::OutboundBlockRelay),
             &self.p2p_config.peer_manager_config,
+            self.time_getter.get_time(),
         ) {
             log::info!("block relay peer {peer_id} is selected for eviction");
             self.disconnect(peer_id, PeerDisconnectionDbAction::Keep, None);
@@ -844,6 +846,7 @@ where
         if let Some(peer_id) = peers_eviction::select_for_eviction_full_relay(
             self.eviction_candidates(PeerRole::OutboundFullRelay),
             &self.p2p_config.peer_manager_config,
+            self.time_getter.get_time(),
         ) {
             log::info!("full relay peer {peer_id} is selected for eviction");
             self.disconnect(peer_id, PeerDisconnectionDbAction::Keep, None);
@@ -943,6 +946,7 @@ where
             discovered_own_address,
             last_tip_block_time: None,
             last_tx_time: None,
+            block_sync_status: PeerBlockSyncStatus::new(),
         };
 
         Self::send_own_address_to_peer(&mut self.peer_connectivity_handle, &peer);
@@ -1250,7 +1254,7 @@ where
         // TODO: in bitcoin they also try to create an extra outbound full relay connection
         // to an address in a reachable network in which there are no outbound full relay or
         // manual connections (see CConnman::MaybePickPreferredNetwork for reference).
-        // See the TODO section of https://github.com/mintlayer/mintlayer-core/issues/832
+        // See https://github.com/mintlayer/mintlayer-core/issues/1433
 
         for address in &new_full_relay_conn_addresses {
             let addr_group = AddressGroup::from_peer_address(&address.as_peer_address());
@@ -1495,6 +1499,15 @@ where
                     peer.last_tx_time = Some(self.time_getter.get_time());
                 }
             }
+            PeerManagerEvent::PeerBlockSyncStatusUpdate {
+                peer_id,
+                new_status: status,
+            } => {
+                if let Some(peer) = self.peers.get_mut(&peer_id) {
+                    log::debug!("Block sync status update received from peer {peer_id}, new status is {status:?}");
+                    peer.block_sync_status = status;
+                }
+            }
             PeerManagerEvent::GetPeerCount(response_sender) => {
                 response_sender.send(self.active_peer_count());
             }
diff --git a/p2p/src/peer_manager/peer_context.rs b/p2p/src/peer_manager/peer_context.rs
index b7d29d6ee1..d8a012a739 100644
--- a/p2p/src/peer_manager/peer_context.rs
+++ b/p2p/src/peer_manager/peer_context.rs
@@ -21,6 +21,7 @@ use utils::{bloom_filters::rolling_bloom_filter::RollingBloomFilter, set_flag::S
 
 use crate::{
     net::types::{PeerInfo, PeerRole},
+    sync::sync_status::PeerBlockSyncStatus,
     utils::rate_limiter::RateLimiter,
 };
 
@@ -75,4 +76,7 @@ pub struct PeerContext {
     pub last_tip_block_time: Option<Time>,
 
     pub last_tx_time: Option<Time>,
+
+    /// Certain information from the block sync manager that the peer manager may be interested in.
+    pub block_sync_status: PeerBlockSyncStatus,
 }
diff --git a/p2p/src/peer_manager/peerdb/address_tables/table.rs b/p2p/src/peer_manager/peerdb/address_tables/table.rs
index 45bfbbe1b8..f055edea45 100644
--- a/p2p/src/peer_manager/peerdb/address_tables/table.rs
+++ b/p2p/src/peer_manager/peerdb/address_tables/table.rs
@@ -279,27 +279,51 @@ pub mod test_utils {
         tables: &[&Table],
         count: usize,
         rng: &mut impl Rng,
+    ) -> Vec<SocketAddress> {
+        make_non_colliding_addresses_impl(tables, count, false, rng)
+    }
+
+    pub fn make_non_colliding_addresses_in_distinct_addr_groups(
+        tables: &[&Table],
+        count: usize,
+        rng: &mut impl Rng,
+    ) -> Vec<SocketAddress> {
+        make_non_colliding_addresses_impl(tables, count, true, rng)
+    }
+
+    fn make_non_colliding_addresses_impl(
+        tables: &[&Table],
+        count: usize,
+        in_distinct_addr_groups: bool,
+        rng: &mut impl Rng,
     ) -> Vec<SocketAddress> {
         assert!(count != 0);
 
         let mut idx_set = BTreeSet::new();
+        let mut addr_groups = BTreeSet::new();
         let mut result = Vec::with_capacity(count);
 
         loop {
             let addr = make_random_address(rng);
+            let addr_group = AddressGroup::from_peer_address(&addr.as_peer_address());
 
             let non_colliding = tables.iter().enumerate().all(|(table_idx, table)| {
                 let (bucket_idx, bucket_pos) = table.bucket_coords(&addr);
                 idx_set.get(&(table_idx, bucket_idx, bucket_pos)).is_none()
             });
 
-            if non_colliding {
+            if non_colliding && (!in_distinct_addr_groups || addr_groups.get(&addr_group).is_none())
+            {
                 result.push(addr);
 
                 if result.len() == count {
                     break;
                 }
 
+                if in_distinct_addr_groups {
+                    addr_groups.insert(addr_group);
+                }
+
                 for (table_idx, table) in tables.iter().enumerate() {
                     let (bucket_idx, bucket_pos) = table.bucket_coords(&addr);
                     idx_set.insert((table_idx, bucket_idx, bucket_pos));
diff --git a/p2p/src/peer_manager/peerdb/mod.rs b/p2p/src/peer_manager/peerdb/mod.rs
index 718b0e9acc..ec0da14c46 100644
--- a/p2p/src/peer_manager/peerdb/mod.rs
+++ b/p2p/src/peer_manager/peerdb/mod.rs
@@ -617,4 +617,19 @@ pub mod test_utils {
             rng,
         )
     }
+
+    pub fn make_non_colliding_addresses_for_peer_db_in_distinct_addr_groups<S: PeerDbStorage>(
+        peer_db: &PeerDb<S>,
+        count: usize,
+        rng: &mut impl Rng,
+    ) -> Vec<SocketAddress> {
+        make_non_colliding_addresses_in_distinct_addr_groups(
+            &[
+                peer_db.address_tables().new_addr_table(),
+                peer_db.address_tables().tried_addr_table(),
+            ],
+            count,
+            rng,
+        )
+    }
 }
diff --git a/p2p/src/peer_manager/peers_eviction/mod.rs b/p2p/src/peer_manager/peers_eviction/mod.rs
index db9a0176af..1793364051 100644
--- a/p2p/src/peer_manager/peers_eviction/mod.rs
+++ b/p2p/src/peer_manager/peers_eviction/mod.rs
@@ -63,6 +63,10 @@ pub struct EvictionCandidate {
     last_tip_block_time: Option<Time>,
 
     last_tx_time: Option<Time>,
+
+    /// The time since which we've been expecting a block from the peer; if None, we're not
+    /// expecting any blocks from it.
+    expecting_blocks_since: Option<Time>,
 }
 
 pub struct RandomState(u64, u64);
@@ -91,11 +95,13 @@ impl EvictionCandidate {
             peer_role: peer.peer_role,
             last_tip_block_time: peer.last_tip_block_time,
             last_tx_time: peer.last_tx_time,
+
+            expecting_blocks_since: peer.block_sync_status.expecting_blocks_since,
         }
     }
 }
 
-fn filter_old_peers(
+fn filter_mature_peers(
     mut candidates: Vec<EvictionCandidate>,
     age: Duration,
 ) -> Vec<EvictionCandidate> {
@@ -201,12 +207,14 @@ pub fn select_for_eviction_inbound(
 pub fn select_for_eviction_block_relay(
     candidates: Vec<EvictionCandidate>,
     config: &PeerManagerConfig,
+    now: Time,
 ) -> Option<PeerId> {
     select_for_eviction_outbound(
         candidates,
         PeerRole::OutboundBlockRelay,
         *config.outbound_block_relay_connection_min_age,
         *config.outbound_block_relay_count,
+        now,
     )
 }
 
@@ -214,47 +222,87 @@ pub fn select_for_eviction_block_relay(
 pub fn select_for_eviction_full_relay(
     candidates: Vec<EvictionCandidate>,
     config: &PeerManagerConfig,
+    now: Time,
 ) -> Option<PeerId> {
     // TODO: in bitcoin they protect full relay peers from eviction if there are no other
     // connection to their network (counting outbound-full-relay and manual peers). We should
     // probably do the same.
-    // See the TODO section of https://github.com/mintlayer/mintlayer-core/issues/832
+    // See https://github.com/mintlayer/mintlayer-core/issues/1432
     select_for_eviction_outbound(
         candidates,
         PeerRole::OutboundFullRelay,
         *config.outbound_full_relay_connection_min_age,
         *config.outbound_full_relay_count,
+        now,
     )
 }
 
+/// If we've been expecting a block from a peer for a duration less or equal to this one,
+/// we'll try to avoid evicting it (by assuming that it has sent us a block just now).
+pub const BLOCK_EXPECTATION_MAX_DURATION: Duration = Duration::from_secs(5);
+
+/// Extended eviction candidate info for outbound peer eviction.
+#[derive(Debug)]
+struct EvictionCandidateExtOutbound {
+    ec: EvictionCandidate,
+    /// This will be set to 'now' if the peer has a non-empty expecting_blocks_since value
+    /// and it's recent enough.
+    effective_last_tip_block_time: Option<Time>,
+}
+
+impl EvictionCandidateExtOutbound {
+    fn new(ec: EvictionCandidate, now: Time) -> Self {
+        let effective_last_tip_block_time =
+            if ec.expecting_blocks_since.is_some_and(|expecting_blocks_since| {
+                (expecting_blocks_since + BLOCK_EXPECTATION_MAX_DURATION).expect("Cannot happen")
+                    >= now
+            }) {
+                Some(now)
+            } else {
+                ec.last_tip_block_time
+            };
+        Self {
+            ec,
+            effective_last_tip_block_time,
+        }
+    }
+}
+
 fn select_for_eviction_outbound(
     candidates: Vec<EvictionCandidate>,
     peer_role: PeerRole,
     min_age: Duration,
     max_count: usize,
+    now: Time,
 ) -> Option<PeerId> {
     debug_assert!(candidates.iter().all(|c| c.peer_role == peer_role));
 
     // Give peers some time to have a chance to send blocks.
-    // TODO: in bitcoin, in addition to checking MINIMUM_CONNECT_TIME, they also check whether
-    // there are blocks in-flight with this peer; we should consider doing it too.
-    // See the TODO section of https://github.com/mintlayer/mintlayer-core/issues/832
-    let mut candidates = filter_old_peers(candidates, min_age);
+    let candidates = filter_mature_peers(candidates, min_age);
     if candidates.len() <= max_count {
         return None;
     }
 
+    let mut candidates: Vec<_> = candidates
+        .into_iter()
+        .map(|ec| EvictionCandidateExtOutbound::new(ec, now))
+        .collect();
+
     // Starting from the youngest, disconnect the first peer that never sent a new blockchain tip
-    candidates.sort_by_key(|peer| peer.age);
+    candidates.sort_by_key(|peer| peer.ec.age);
     for peer in candidates.iter() {
-        if peer.last_tip_block_time.is_none() {
-            return Some(peer.peer_id);
+        if peer.effective_last_tip_block_time.is_none() {
+            return Some(peer.ec.peer_id);
         }
     }
 
     // Disconnect the peer who sent a new blockchain tip a long time ago
-    candidates.sort_by_key(|peer| peer.last_tip_block_time);
-    candidates.first().map(|peer| peer.peer_id)
+    candidates
+        .iter()
+        .min_by(|peer1, peer2| {
+            peer1.effective_last_tip_block_time.cmp(&peer2.effective_last_tip_block_time)
+        })
+        .map(|peer| peer.ec.peer_id)
 }
 
 #[cfg(test)]
diff --git a/p2p/src/peer_manager/peers_eviction/tests.rs b/p2p/src/peer_manager/peers_eviction/tests.rs
index dc9adeef62..ee46ebf068 100644
--- a/p2p/src/peer_manager/peers_eviction/tests.rs
+++ b/p2p/src/peer_manager/peers_eviction/tests.rs
@@ -47,6 +47,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                 peer_role: PeerRole::Inbound,
                 last_tip_block_time: None,
                 last_tx_time: None,
+                expecting_blocks_since: None,
             },],
             1
         ),
@@ -65,6 +66,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -74,6 +76,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -88,6 +91,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 
@@ -103,6 +107,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -112,6 +117,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -126,6 +132,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 
@@ -141,6 +148,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -150,6 +158,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -159,6 +168,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -173,6 +183,7 @@ fn test_filter_address_group(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 }
@@ -198,6 +209,7 @@ fn test_ping(#[case] seed: Seed) {
                 peer_role: PeerRole::Inbound,
                 last_tip_block_time: None,
                 last_tx_time: None,
+                expecting_blocks_since: None,
             },],
             1
         ),
@@ -216,6 +228,7 @@ fn test_ping(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -225,6 +238,7 @@ fn test_ping(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -239,6 +253,7 @@ fn test_ping(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 
@@ -254,6 +269,7 @@ fn test_ping(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -263,6 +279,7 @@ fn test_ping(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -272,6 +289,7 @@ fn test_ping(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -286,6 +304,7 @@ fn test_ping(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 }
@@ -311,6 +330,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
                 peer_role: PeerRole::Inbound,
                 last_tip_block_time: None,
                 last_tx_time: None,
+                expecting_blocks_since: None,
             },],
             1
         ),
@@ -329,6 +349,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -340,6 +361,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
                             Duration::from_secs(10000000)
                         )),
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -354,6 +376,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 
@@ -371,6 +394,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
                             Duration::from_secs(10000000)
                         )),
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -382,6 +406,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
                             Duration::from_secs(10000001)
                         )),
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -393,6 +418,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
                             Duration::from_secs(10000002)
                         )),
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -407,6 +433,7 @@ fn test_filter_by_last_block_time(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: Some(Time::from_secs_since_epoch(10000000)),
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 }
@@ -432,6 +459,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
                 peer_role: PeerRole::Inbound,
                 last_tip_block_time: None,
                 last_tx_time: None,
+                expecting_blocks_since: None,
             },],
             1
         ),
@@ -450,6 +478,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: Some(Time::from_secs_since_epoch(1000000)),
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -459,6 +488,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: None,
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -473,6 +503,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         },]
     );
 
@@ -488,6 +519,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: Some(Time::from_secs_since_epoch(10000000)),
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -497,6 +529,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: Some(Time::from_secs_since_epoch(10000001)),
+                        expecting_blocks_since: None,
                     },
                     EvictionCandidate {
                         age: Duration::ZERO,
@@ -506,6 +539,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
                         peer_role: PeerRole::Inbound,
                         last_tip_block_time: None,
                         last_tx_time: Some(Time::from_secs_since_epoch(10000002)),
+                        expecting_blocks_since: None,
                     },
                 ],
                 &mut rng
@@ -520,6 +554,7 @@ fn test_filter_by_last_transaction_time(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: Some(Time::from_secs_since_epoch(10000000)),
+            expecting_blocks_since: None,
         },]
     );
 }
@@ -546,6 +581,7 @@ fn test_find_group_most_connections(#[case] seed: Seed) {
             peer_role: PeerRole::Inbound,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         }]),
         Some(peer1)
     );
@@ -562,6 +598,7 @@ fn test_find_group_most_connections(#[case] seed: Seed) {
                     peer_role: PeerRole::Inbound,
                     last_tip_block_time: None,
                     last_tx_time: None,
+                    expecting_blocks_since: None,
                 },
                 EvictionCandidate {
                     age: Duration::ZERO,
@@ -571,6 +608,7 @@ fn test_find_group_most_connections(#[case] seed: Seed) {
                     peer_role: PeerRole::Inbound,
                     last_tip_block_time: None,
                     last_tx_time: None,
+                    expecting_blocks_since: None,
                 }
             ],
             &mut rng
@@ -589,6 +627,7 @@ fn test_find_group_most_connections(#[case] seed: Seed) {
                     peer_role: PeerRole::Inbound,
                     last_tip_block_time: None,
                     last_tx_time: None,
+                    expecting_blocks_since: None,
                 },
                 EvictionCandidate {
                     age: Duration::ZERO,
@@ -598,6 +637,7 @@ fn test_find_group_most_connections(#[case] seed: Seed) {
                     peer_role: PeerRole::Inbound,
                     last_tip_block_time: None,
                     last_tx_time: None,
+                    expecting_blocks_since: None,
                 },
                 EvictionCandidate {
                     age: Duration::ZERO,
@@ -607,6 +647,7 @@ fn test_find_group_most_connections(#[case] seed: Seed) {
                     peer_role: PeerRole::Inbound,
                     last_tip_block_time: None,
                     last_tx_time: None,
+                    expecting_blocks_since: None,
                 },
             ],
             &mut rng
@@ -624,6 +665,7 @@ fn random_eviction_candidate(rng: &mut impl Rng) -> EvictionCandidate {
         peer_role: PeerRole::Inbound,
         last_tip_block_time: None,
         last_tx_time: None,
+        expecting_blocks_since: None,
     }
 }
 
@@ -697,6 +739,7 @@ fn test_block_relay_eviction_young_old_peers(#[case] seed: Seed) {
     let peer2 = PeerId::new();
     let peer3 = PeerId::new();
 
+    let now = Time::from_secs_since_epoch(100000);
     let min_age = Duration::from_secs(5000);
     let config = config_with_block_relay_conn_limits(2, min_age);
 
@@ -709,6 +752,7 @@ fn test_block_relay_eviction_young_old_peers(#[case] seed: Seed) {
             peer_role: PeerRole::OutboundBlockRelay,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         }
     }
 
@@ -719,7 +763,7 @@ fn test_block_relay_eviction_young_old_peers(#[case] seed: Seed) {
         make_candidate(peer3, min_age - Duration::from_secs(1)),
     ];
     assert_eq!(
-        select_for_eviction_block_relay(shuffle_vec(candidates, &mut rng), &config),
+        select_for_eviction_block_relay(shuffle_vec(candidates, &mut rng), &config, now),
         None
     );
 
@@ -731,13 +775,13 @@ fn test_block_relay_eviction_young_old_peers(#[case] seed: Seed) {
     ];
     let candidates = shuffle_vec(candidates, &mut rng);
     assert_eq!(
-        select_for_eviction_block_relay(candidates.clone(), &config),
+        select_for_eviction_block_relay(candidates.clone(), &config, now),
         Some(peer3)
     );
 
     // But if the limits are lifted, no eviction happens.
     assert_eq!(
-        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits()),
+        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits(), now),
         None
     );
 }
@@ -753,10 +797,16 @@ fn test_block_relay_eviction_no_blocks(#[case] seed: Seed) {
     let peer2 = PeerId::new();
     let peer3 = PeerId::new();
 
+    let now_as_secs = 100000;
+    let now = Time::from_secs_since_epoch(now_as_secs);
     let min_age = Duration::from_secs(5000);
     let config = config_with_block_relay_conn_limits(2, min_age);
 
-    fn make_candidate(peer_id: PeerId, last_tip_block_time_secs: Option<u64>) -> EvictionCandidate {
+    fn make_candidate(
+        peer_id: PeerId,
+        last_tip_block_time_secs: Option<u64>,
+        expecting_blocks_since_secs: Option<u64>,
+    ) -> EvictionCandidate {
         EvictionCandidate {
             age: Duration::from_secs(10000),
             peer_id,
@@ -765,24 +815,68 @@ fn test_block_relay_eviction_no_blocks(#[case] seed: Seed) {
             peer_role: PeerRole::OutboundBlockRelay,
             last_tip_block_time: last_tip_block_time_secs.map(Time::from_secs_since_epoch),
             last_tx_time: None,
+            expecting_blocks_since: expecting_blocks_since_secs.map(Time::from_secs_since_epoch),
         }
     }
 
-    // The peer that never sent us new blocks is evicted
+    // The peer that never sent us new blocks is evicted.
     let candidates = vec![
-        make_candidate(peer1, Some(10000)),
-        make_candidate(peer2, Some(20000)),
-        make_candidate(peer3, None),
+        make_candidate(peer1, Some(10000), None),
+        make_candidate(peer2, Some(20000), None),
+        make_candidate(peer3, None, None),
     ];
     let candidates = shuffle_vec(candidates, &mut rng);
     assert_eq!(
-        select_for_eviction_block_relay(candidates.clone(), &config),
+        select_for_eviction_block_relay(candidates.clone(), &config, now),
         Some(peer3)
     );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
 
+    // The previously evicted peer now has `expecting_blocks_since` within the limit;
+    // the next worst peer should be evicted instead.
+    let candidates = vec![
+        make_candidate(peer1, Some(10000), None),
+        make_candidate(peer2, Some(20000), None),
+        make_candidate(
+            peer3,
+            None,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs()),
+        ),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_block_relay(candidates.clone(), &config, now),
+        Some(peer1)
+    );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
+
+    // The same peer now has `expecting_blocks_since` below the limit;
+    // this time it should be evicted.
+    let candidates = vec![
+        make_candidate(peer1, Some(10000), None),
+        make_candidate(peer2, Some(20000), None),
+        make_candidate(
+            peer3,
+            None,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs() - 1),
+        ),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_block_relay(candidates.clone(), &config, now),
+        Some(peer3)
+    );
     // But if the limits are lifted, no eviction happens.
     assert_eq!(
-        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits()),
+        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits(), now),
         None
     );
 }
@@ -798,10 +892,16 @@ fn test_block_relay_eviction_old_blocks(#[case] seed: Seed) {
     let peer2 = PeerId::new();
     let peer3 = PeerId::new();
 
+    let now_as_secs = 100000;
+    let now = Time::from_secs_since_epoch(now_as_secs);
     let min_age = Duration::from_secs(5000);
     let config = config_with_block_relay_conn_limits(2, min_age);
 
-    fn make_candidate(peer_id: PeerId, last_tip_block_time_secs: u64) -> EvictionCandidate {
+    fn make_candidate(
+        peer_id: PeerId,
+        last_tip_block_time_secs: u64,
+        expecting_blocks_since_secs: Option<u64>,
+    ) -> EvictionCandidate {
         EvictionCandidate {
             age: Duration::from_secs(10000),
             peer_id,
@@ -810,24 +910,68 @@ fn test_block_relay_eviction_old_blocks(#[case] seed: Seed) {
             peer_role: PeerRole::OutboundBlockRelay,
             last_tip_block_time: Some(Time::from_secs_since_epoch(last_tip_block_time_secs)),
             last_tx_time: None,
+            expecting_blocks_since: expecting_blocks_since_secs.map(Time::from_secs_since_epoch),
         }
     }
 
-    // The peer that sent blocks a long time ago is evicted
+    // The peer that sent blocks a long time ago is evicted.
     let candidates = vec![
-        make_candidate(peer1, 10000),
-        make_candidate(peer2, 20000),
-        make_candidate(peer3, 30000),
+        make_candidate(peer1, 10000, None),
+        make_candidate(peer2, 20000, None),
+        make_candidate(peer3, 30000, None),
     ];
     let candidates = shuffle_vec(candidates, &mut rng);
     assert_eq!(
-        select_for_eviction_block_relay(candidates.clone(), &config),
+        select_for_eviction_block_relay(candidates.clone(), &config, now),
         Some(peer1)
     );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
 
+    // The previously evicted peer now has `expecting_blocks_since` within the limit;
+    // the next worst peer should be evicted instead.
+    let candidates = vec![
+        make_candidate(
+            peer1,
+            10000,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs()),
+        ),
+        make_candidate(peer2, 20000, None),
+        make_candidate(peer3, 30000, None),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_block_relay(candidates.clone(), &config, now),
+        Some(peer2)
+    );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
+
+    // The same peer now has `expecting_blocks_since` below the limit;
+    // this time it should be evicted.
+    let candidates = vec![
+        make_candidate(
+            peer1,
+            10000,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs() - 1),
+        ),
+        make_candidate(peer2, 20000, None),
+        make_candidate(peer3, 30000, None),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_block_relay(candidates.clone(), &config, now),
+        Some(peer1)
+    );
     // But if the limits are lifted, no eviction happens.
     assert_eq!(
-        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits()),
+        select_for_eviction_block_relay(candidates, &config_with_no_outbound_conn_limits(), now),
         None
     );
 }
@@ -843,6 +987,7 @@ fn test_full_relay_eviction_young_old_peers(#[case] seed: Seed) {
     let peer2 = PeerId::new();
     let peer3 = PeerId::new();
 
+    let now = Time::from_secs_since_epoch(100000);
     let min_age = Duration::from_secs(5000);
     let config = config_with_full_relay_conn_limits(2, min_age);
 
@@ -855,6 +1000,7 @@ fn test_full_relay_eviction_young_old_peers(#[case] seed: Seed) {
             peer_role: PeerRole::OutboundFullRelay,
             last_tip_block_time: None,
             last_tx_time: None,
+            expecting_blocks_since: None,
         }
     }
 
@@ -865,7 +1011,7 @@ fn test_full_relay_eviction_young_old_peers(#[case] seed: Seed) {
         make_candidate(peer3, min_age - Duration::from_secs(1)),
     ];
     assert_eq!(
-        select_for_eviction_full_relay(shuffle_vec(candidates, &mut rng), &config),
+        select_for_eviction_full_relay(shuffle_vec(candidates, &mut rng), &config, now),
         None
     );
 
@@ -877,13 +1023,13 @@ fn test_full_relay_eviction_young_old_peers(#[case] seed: Seed) {
     ];
     let candidates = shuffle_vec(candidates, &mut rng);
     assert_eq!(
-        select_for_eviction_full_relay(candidates.clone(), &config),
+        select_for_eviction_full_relay(candidates.clone(), &config, now),
         Some(peer3)
     );
 
     // But if the limits are lifted, no eviction happens.
     assert_eq!(
-        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits()),
+        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits(), now),
         None
     );
 }
@@ -899,10 +1045,16 @@ fn test_full_relay_eviction_no_blocks(#[case] seed: Seed) {
     let peer2 = PeerId::new();
     let peer3 = PeerId::new();
 
+    let now_as_secs = 100000;
+    let now = Time::from_secs_since_epoch(now_as_secs);
     let min_age = Duration::from_secs(5000);
     let config = config_with_full_relay_conn_limits(2, min_age);
 
-    fn make_candidate(peer_id: PeerId, last_tip_block_time_secs: Option<u64>) -> EvictionCandidate {
+    fn make_candidate(
+        peer_id: PeerId,
+        last_tip_block_time_secs: Option<u64>,
+        expecting_blocks_since_secs: Option<u64>,
+    ) -> EvictionCandidate {
         EvictionCandidate {
             age: Duration::from_secs(10000),
             peer_id,
@@ -911,24 +1063,68 @@ fn test_full_relay_eviction_no_blocks(#[case] seed: Seed) {
             peer_role: PeerRole::OutboundFullRelay,
             last_tip_block_time: last_tip_block_time_secs.map(Time::from_secs_since_epoch),
             last_tx_time: None,
+            expecting_blocks_since: expecting_blocks_since_secs.map(Time::from_secs_since_epoch),
         }
     }
 
-    // The peer that never sent us new blocks is evicted
+    // The peer that never sent us new blocks is evicted.
     let candidates = vec![
-        make_candidate(peer1, Some(10000)),
-        make_candidate(peer2, Some(20000)),
-        make_candidate(peer3, None),
+        make_candidate(peer1, Some(10000), None),
+        make_candidate(peer2, Some(20000), None),
+        make_candidate(peer3, None, None),
     ];
     let candidates = shuffle_vec(candidates, &mut rng);
     assert_eq!(
-        select_for_eviction_full_relay(candidates.clone(), &config),
+        select_for_eviction_full_relay(candidates.clone(), &config, now),
         Some(peer3)
     );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
 
+    // The previously evicted peer now has `expecting_blocks_since` within the limit;
+    // the next worst peer should be evicted instead.
+    let candidates = vec![
+        make_candidate(peer1, Some(10000), None),
+        make_candidate(peer2, Some(20000), None),
+        make_candidate(
+            peer3,
+            None,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs()),
+        ),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_full_relay(candidates.clone(), &config, now),
+        Some(peer1)
+    );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
+
+    // The same peer now has `expecting_blocks_since` below the limit;
+    // this time it should be evicted.
+    let candidates = vec![
+        make_candidate(peer1, Some(10000), None),
+        make_candidate(peer2, Some(20000), None),
+        make_candidate(
+            peer3,
+            None,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs() - 1),
+        ),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_full_relay(candidates.clone(), &config, now),
+        Some(peer3)
+    );
     // But if the limits are lifted, no eviction happens.
     assert_eq!(
-        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits()),
+        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits(), now),
         None
     );
 }
@@ -944,10 +1140,16 @@ fn test_full_relay_eviction_old_blocks(#[case] seed: Seed) {
     let peer2 = PeerId::new();
     let peer3 = PeerId::new();
 
+    let now_as_secs = 100000;
+    let now = Time::from_secs_since_epoch(now_as_secs);
     let min_age = Duration::from_secs(5000);
     let config = config_with_full_relay_conn_limits(2, min_age);
 
-    fn make_candidate(peer_id: PeerId, last_tip_block_time_secs: u64) -> EvictionCandidate {
+    fn make_candidate(
+        peer_id: PeerId,
+        last_tip_block_time_secs: u64,
+        expecting_blocks_since_secs: Option<u64>,
+    ) -> EvictionCandidate {
         EvictionCandidate {
             age: Duration::from_secs(10000),
             peer_id,
@@ -956,24 +1158,68 @@ fn test_full_relay_eviction_old_blocks(#[case] seed: Seed) {
             peer_role: PeerRole::OutboundFullRelay,
             last_tip_block_time: Some(Time::from_secs_since_epoch(last_tip_block_time_secs)),
             last_tx_time: None,
+            expecting_blocks_since: expecting_blocks_since_secs.map(Time::from_secs_since_epoch),
         }
     }
 
-    // The peer that sent blocks a long time ago is evicted
+    // The peer that sent blocks a long time ago is evicted.
     let candidates = vec![
-        make_candidate(peer1, 10000),
-        make_candidate(peer2, 20000),
-        make_candidate(peer3, 30000),
+        make_candidate(peer1, 10000, None),
+        make_candidate(peer2, 20000, None),
+        make_candidate(peer3, 30000, None),
     ];
     let candidates = shuffle_vec(candidates, &mut rng);
     assert_eq!(
-        select_for_eviction_full_relay(candidates.clone(), &config),
+        select_for_eviction_full_relay(candidates.clone(), &config, now),
         Some(peer1)
     );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
 
+    // The previously evicted peer now has `expecting_blocks_since` within the limit;
+    // the next worst peer should be evicted instead.
+    let candidates = vec![
+        make_candidate(
+            peer1,
+            10000,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs()),
+        ),
+        make_candidate(peer2, 20000, None),
+        make_candidate(peer3, 30000, None),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_full_relay(candidates.clone(), &config, now),
+        Some(peer2)
+    );
+    // But if the limits are lifted, no eviction happens.
+    assert_eq!(
+        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits(), now),
+        None
+    );
+
+    // The same peer now has `expecting_blocks_since` below the limit;
+    // this time it should be evicted.
+    let candidates = vec![
+        make_candidate(
+            peer1,
+            10000,
+            Some(now_as_secs - BLOCK_EXPECTATION_MAX_DURATION.as_secs() - 1),
+        ),
+        make_candidate(peer2, 20000, None),
+        make_candidate(peer3, 30000, None),
+    ];
+    let candidates = shuffle_vec(candidates, &mut rng);
+    assert_eq!(
+        select_for_eviction_full_relay(candidates.clone(), &config, now),
+        Some(peer1)
+    );
     // But if the limits are lifted, no eviction happens.
     assert_eq!(
-        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits()),
+        select_for_eviction_full_relay(candidates, &config_with_no_outbound_conn_limits(), now),
         None
     );
 }
diff --git a/p2p/src/peer_manager/tests/addresses.rs b/p2p/src/peer_manager/tests/addresses.rs
index a5ffce8820..7573a955fb 100644
--- a/p2p/src/peer_manager/tests/addresses.rs
+++ b/p2p/src/peer_manager/tests/addresses.rs
@@ -46,7 +46,7 @@ use crate::{
         self,
         tests::{
             make_peer_manager_custom,
-            utils::{cmd_to_peer_man_msg, make_peer_info},
+            utils::{cmd_to_peer_man_msg, make_full_relay_peer_info},
         },
         OutboundConnectType, PeerManager, DNS_SEED_QUERY_INTERVAL,
     },
@@ -678,7 +678,7 @@ async fn accept_outbound_connection(
         .send(ConnectivityEvent::OutboundAccepted {
             peer_address: *peer_address,
             bind_address: *local_bind_address,
-            peer_info: make_peer_info(peer_id, chain_config),
+            peer_info: make_full_relay_peer_info(peer_id, chain_config),
             node_address_as_seen_by_peer: None,
         })
         .unwrap();
diff --git a/p2p/src/peer_manager/tests/connections.rs b/p2p/src/peer_manager/tests/connections.rs
index 868d727219..32f7b40f8b 100644
--- a/p2p/src/peer_manager/tests/connections.rs
+++ b/p2p/src/peer_manager/tests/connections.rs
@@ -46,7 +46,7 @@ use crate::{
         peerdb::{self, config::PeerDbConfig},
         tests::{
             get_connected_peers, run_peer_manager,
-            utils::{make_peer_info, recv_command_advance_time},
+            utils::{expect_connect_cmd, make_full_relay_peer_info, recv_command_advance_time},
         },
         MaxInboundConnections, PeerManager, PeerManagerConfig,
     },
@@ -1487,14 +1487,14 @@ async fn feeler_connections_test_impl(seed: Seed) {
 
     log::debug!("Expecting normal outbound connection attempt");
     let cmd = cmd_receiver.recv().await.unwrap();
-    let outbound_peer_addr = expect_connect(&cmd, &mut addresses);
+    let outbound_peer_addr = expect_connect_cmd(&cmd, &mut addresses);
 
     let outbound_peer_id = PeerId::new();
     conn_event_sender
         .send(ConnectivityEvent::OutboundAccepted {
             peer_address: outbound_peer_addr,
             bind_address,
-            peer_info: make_peer_info(outbound_peer_id, &chain_config),
+            peer_info: make_full_relay_peer_info(outbound_peer_id, &chain_config),
             node_address_as_seen_by_peer: None,
         })
         .unwrap();
@@ -1534,7 +1534,7 @@ async fn feeler_connections_test_impl(seed: Seed) {
             recv_command_advance_time(&mut cmd_receiver, &time_getter, feeler_connections_interval)
                 .await
                 .unwrap();
-        let addr = expect_connect(&cmd, &mut addresses);
+        let addr = expect_connect_cmd(&cmd, &mut addresses);
         let is_last_addr = addresses.is_empty();
         let should_succeed = {
             let rand_bool = rng.gen_bool(0.5);
@@ -1559,7 +1559,7 @@ async fn feeler_connections_test_impl(seed: Seed) {
                 .send(ConnectivityEvent::OutboundAccepted {
                     peer_address: addr,
                     bind_address,
-                    peer_info: make_peer_info(cur_peer_id, &chain_config),
+                    peer_info: make_full_relay_peer_info(cur_peer_id, &chain_config),
                     node_address_as_seen_by_peer: None,
                 })
                 .unwrap();
@@ -1680,23 +1680,6 @@ mod feeler_connections_test_utils {
         }
     }
 
-    pub fn expect_connect(cmd: &Command, addresses: &mut BTreeSet<SocketAddress>) -> SocketAddress {
-        match cmd {
-            Command::Connect {
-                address,
-                local_services_override: _,
-            } => {
-                log::debug!("Connection attempt to {address} detected");
-                assert!(addresses.contains(address));
-                addresses.remove(address);
-                *address
-            }
-            cmd => {
-                panic!("Unexpected command received: {cmd:?}");
-            }
-        }
-    }
-
     pub fn new_addr_table_as_set<S: PeerDbStorage>(peerdb: &PeerDb<S>) -> BTreeSet<SocketAddress> {
         peerdb
             .address_tables()
diff --git a/p2p/src/peer_manager/tests/eviction.rs b/p2p/src/peer_manager/tests/eviction.rs
new file mode 100644
index 0000000000..d9c27fcb0f
--- /dev/null
+++ b/p2p/src/peer_manager/tests/eviction.rs
@@ -0,0 +1,316 @@
+// Copyright (c) 2021-2024 RBB S.r.l
+// opensource@mintlayer.org
+// SPDX-License-Identifier: MIT
+// Licensed under the MIT License;
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://github.com/mintlayer/mintlayer-core/blob/master/LICENSE
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::{collections::BTreeSet, sync::Arc, time::Duration};
+
+use logging::log;
+use rstest::rstest;
+use test_utils::random::make_seedable_rng;
+use tokio::sync::mpsc;
+
+use p2p_test_utils::{expect_no_recv, expect_recv, P2pBasicTestTimeGetter};
+use test_utils::random::Seed;
+
+use crate::{
+    config::P2pConfig,
+    net::{
+        default_backend::{types::Command, ConnectivityHandle},
+        types::ConnectivityEvent,
+    },
+    peer_manager::{
+        dns_seed::DefaultDnsSeed,
+        peerdb::{self, config::PeerDbConfig, salt::Salt},
+        peers_eviction,
+        tests::utils::{expect_connect_cmd, make_block_relay_peer_info},
+        PeerManager, PeerManagerConfig,
+    },
+    sync::sync_status::PeerBlockSyncStatus,
+    testing_utils::{peerdb_inmemory_store, TestTransportMaker, TestTransportTcp},
+    tests::helpers::PeerManagerObserver,
+    types::peer_id::PeerId,
+};
+use common::{
+    chain::{config, Block},
+    primitives::{user_agent::mintlayer_core_user_agent, Id},
+    Uint256,
+};
+
+use crate::{
+    net::default_backend::{transport::TcpTransportSocket, DefaultNetworkingService},
+    peer_manager::{tests::utils::wait_for_heartbeat, HEARTBEAT_INTERVAL_MAX},
+    PeerManagerEvent,
+};
+
+// 1) Setup the peer manager so that it must open 3 block relay connections, 1 of which is
+// temporary; let it open the connections.
+// 2) Simulate new tip arrival from each peer with 1st peer's tip being the oldest.
+// 3) Based on the TestCase enum, make the peer manager expect (or not) a block from the 1st peer.
+// 4) Advance the time, so that the connections are mature enough for eviction to be possible.
+// The expected result depends on TestCase: if no block was expected from the 1st peer (NoBlocksInFlight),
+// it must be evicted. Same should happen if a block is expected, but the timeout has elapsed (BlockInFlightOld).
+// Otherwise (BlockInFlightRecent), the 2nd peer should be evicted instead.
+mod dont_evict_if_blocks_in_flight {
+    use super::*;
+
+    #[derive(Debug)]
+    enum TestCase {
+        NoBlocksInFlight,
+        BlockInFlightRecent,
+        BlockInFlightOld,
+    }
+
+    #[tracing::instrument(skip(seed))]
+    #[rstest]
+    #[trace]
+    #[case(Seed::from_entropy())]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test(
+        #[case] seed: Seed,
+        #[values(
+            TestCase::NoBlocksInFlight,
+            TestCase::BlockInFlightRecent,
+            TestCase::BlockInFlightOld
+        )]
+        test_case: TestCase,
+    ) {
+        type TestNetworkingService = DefaultNetworkingService<TcpTransportSocket>;
+
+        let mut rng = make_seedable_rng(seed);
+
+        let chain_config = Arc::new(config::create_unit_test_config());
+        // The age should be big enough to allow multiple heartbeats to pass before it may expire.
+        let min_connection_age = Duration::from_secs(60 * 60);
+
+        let p2p_config = Arc::new(P2pConfig {
+            peer_manager_config: PeerManagerConfig {
+                outbound_block_relay_count: 2.into(),
+                outbound_block_relay_extra_count: 1.into(),
+                outbound_block_relay_connection_min_age: min_connection_age.into(),
+
+                outbound_full_relay_count: 0.into(),
+                outbound_full_relay_extra_count: 0.into(),
+
+                enable_feeler_connections: false.into(),
+
+                peerdb_config: PeerDbConfig {
+                    salt: Some(Salt::new_random_with_rng(&mut rng)),
+
+                    new_addr_table_bucket_count: Default::default(),
+                    tried_addr_table_bucket_count: Default::default(),
+                    addr_tables_bucket_size: Default::default(),
+                },
+
+                preserved_inbound_count_address_group: Default::default(),
+                preserved_inbound_count_ping: Default::default(),
+                preserved_inbound_count_new_blocks: Default::default(),
+                preserved_inbound_count_new_transactions: Default::default(),
+
+                max_inbound_connections: Default::default(),
+
+                outbound_full_relay_connection_min_age: Default::default(),
+                stale_tip_time_diff: Default::default(),
+
+                main_loop_tick_interval: Default::default(),
+                feeler_connections_interval: Default::default(),
+            },
+            ping_check_period: Duration::ZERO.into(),
+
+            bind_addresses: Default::default(),
+            socks5_proxy: Default::default(),
+            disable_noise: Default::default(),
+            boot_nodes: Default::default(),
+            boot_nodes_will_stall: Default::default(),
+            reserved_nodes: Default::default(),
+            whitelisted_addresses: Default::default(),
+            ban_threshold: Default::default(),
+            ban_duration: Default::default(),
+            outbound_connection_timeout: Default::default(),
+            ping_timeout: Default::default(),
+            peer_handshake_timeout: Default::default(),
+            max_clock_diff: Default::default(),
+            node_type: Default::default(),
+            allow_discover_private_ips: Default::default(),
+            user_agent: mintlayer_core_user_agent(),
+            sync_stalling_timeout: Default::default(),
+            protocol_config: Default::default(),
+        });
+
+        let bind_address = TestTransportTcp::make_address();
+        let (cmd_sender, mut cmd_receiver) = mpsc::unbounded_channel();
+        let (conn_event_sender, conn_event_receiver) = mpsc::unbounded_channel();
+        let (peer_mgr_event_sender, peer_mgr_event_receiver) =
+            mpsc::unbounded_channel::<PeerManagerEvent>();
+        let time_getter = P2pBasicTestTimeGetter::new();
+        let connectivity_handle = ConnectivityHandle::<TestNetworkingService>::new(
+            vec![],
+            cmd_sender,
+            conn_event_receiver,
+        );
+        let (peer_mgr_notification_sender, mut peer_mgr_notification_receiver) =
+            mpsc::unbounded_channel();
+        let peer_mgr_observer = Box::new(PeerManagerObserver::new(peer_mgr_notification_sender));
+
+        let mut peer_mgr = PeerManager::<TestNetworkingService, _>::new_generic(
+            Arc::clone(&chain_config),
+            Arc::clone(&p2p_config),
+            connectivity_handle,
+            peer_mgr_event_receiver,
+            time_getter.get_time_getter(),
+            peerdb_inmemory_store(),
+            Some(peer_mgr_observer),
+            Box::new(DefaultDnsSeed::new(
+                Arc::clone(&chain_config),
+                Arc::clone(&p2p_config),
+            )),
+        )
+        .unwrap();
+
+        let addr_count = 3;
+        let addresses =
+            peerdb::test_utils::make_non_colliding_addresses_for_peer_db_in_distinct_addr_groups(
+                &peer_mgr.peerdb,
+                addr_count,
+                &mut rng,
+            );
+        let mut addresses = BTreeSet::from_iter(addresses.into_iter());
+        for addr in &addresses {
+            peer_mgr.peerdb.peer_discovered(*addr);
+        }
+        let peer_mgr_join_handle = logging::spawn_in_current_span(async move {
+            let mut peer_mgr = peer_mgr;
+            let _ = peer_mgr.run_internal(None).await;
+            peer_mgr
+        });
+
+        let mut peer_ids = Vec::new();
+
+        log::debug!("Expecting outbound connection attempt #1");
+        let cmd = expect_recv!(cmd_receiver);
+        let peer1_addr = expect_connect_cmd(&cmd, &mut addresses);
+
+        log::debug!("Expecting outbound connection attempt #2");
+        let cmd = expect_recv!(cmd_receiver);
+        let peer2_addr = expect_connect_cmd(&cmd, &mut addresses);
+
+        log::debug!("Expecting outbound connection attempt #3");
+        let cmd = expect_recv!(cmd_receiver);
+        let peer3_addr = expect_connect_cmd(&cmd, &mut addresses);
+
+        for peer_addr in [peer1_addr, peer2_addr, peer3_addr] {
+            let peer_id = PeerId::new();
+            conn_event_sender
+                .send(ConnectivityEvent::OutboundAccepted {
+                    peer_address: peer_addr,
+                    bind_address,
+                    peer_info: make_block_relay_peer_info(peer_id, &chain_config),
+                    node_address_as_seen_by_peer: None,
+                })
+                .unwrap();
+
+            log::debug!("Expecting Command::Accept");
+            let cmd = expect_recv!(cmd_receiver);
+            assert_eq!(cmd, Command::Accept { peer_id });
+
+            peer_ids.push(peer_id);
+        }
+
+        // One unconditional heartbeat must have occurred early, skip it.
+        wait_for_heartbeat(&mut peer_mgr_notification_receiver).await;
+
+        // No other commands are sent immediately.
+        expect_no_recv!(cmd_receiver);
+
+        peer_mgr_event_sender
+            .send(PeerManagerEvent::NewTipReceived {
+                peer_id: peer_ids[0],
+                block_id: Id::<Block>::new(Uint256::from_u64(1).into()),
+            })
+            .unwrap();
+        time_getter.advance_time(HEARTBEAT_INTERVAL_MAX);
+        wait_for_heartbeat(&mut peer_mgr_notification_receiver).await;
+
+        time_getter.advance_time(Duration::from_secs(1));
+
+        peer_mgr_event_sender
+            .send(PeerManagerEvent::NewTipReceived {
+                peer_id: peer_ids[1],
+                block_id: Id::<Block>::new(Uint256::from_u64(2).into()),
+            })
+            .unwrap();
+        time_getter.advance_time(HEARTBEAT_INTERVAL_MAX);
+        wait_for_heartbeat(&mut peer_mgr_notification_receiver).await;
+
+        time_getter.advance_time(Duration::from_secs(1));
+
+        peer_mgr_event_sender
+            .send(PeerManagerEvent::NewTipReceived {
+                peer_id: peer_ids[2],
+                block_id: Id::<Block>::new(Uint256::from_u64(3).into()),
+            })
+            .unwrap();
+        time_getter.advance_time(HEARTBEAT_INTERVAL_MAX);
+        wait_for_heartbeat(&mut peer_mgr_notification_receiver).await;
+
+        let next_time_advancement = min_connection_age + Duration::from_secs(1);
+
+        let (expect_blocks_since, expected_peer_to_disconnect) = match test_case {
+            TestCase::NoBlocksInFlight => (None, peer_ids[0]),
+            TestCase::BlockInFlightRecent => {
+                let expect_blocks_since = (time_getter.get_time_getter().get_time()
+                    + (next_time_advancement - peers_eviction::BLOCK_EXPECTATION_MAX_DURATION
+                        + Duration::from_secs(1)))
+                .unwrap();
+
+                (Some(expect_blocks_since), peer_ids[1])
+            }
+            TestCase::BlockInFlightOld => {
+                let expect_blocks_since = (time_getter.get_time_getter().get_time()
+                    + (next_time_advancement
+                        - peers_eviction::BLOCK_EXPECTATION_MAX_DURATION
+                        - Duration::from_secs(1)))
+                .unwrap();
+
+                (Some(expect_blocks_since), peer_ids[0])
+            }
+        };
+
+        if let Some(expect_blocks_since) = expect_blocks_since {
+            peer_mgr_event_sender
+                .send(PeerManagerEvent::PeerBlockSyncStatusUpdate {
+                    peer_id: peer_ids[0],
+                    new_status: PeerBlockSyncStatus {
+                        expecting_blocks_since: Some(expect_blocks_since),
+                    },
+                })
+                .unwrap();
+        }
+
+        // Advance the time so that all connections become mature and can be evicted from now on.
+        time_getter.advance_time(next_time_advancement);
+
+        let cmd = expect_recv!(cmd_receiver);
+        assert_eq!(
+            cmd,
+            Command::Disconnect {
+                peer_id: expected_peer_to_disconnect
+            }
+        );
+
+        drop(conn_event_sender);
+        drop(peer_mgr_event_sender);
+
+        let _peer_mgr = peer_mgr_join_handle.await.unwrap();
+    }
+}
diff --git a/p2p/src/peer_manager/tests/mod.rs b/p2p/src/peer_manager/tests/mod.rs
index e26e5f76fb..8482961e16 100644
--- a/p2p/src/peer_manager/tests/mod.rs
+++ b/p2p/src/peer_manager/tests/mod.rs
@@ -17,6 +17,7 @@ mod addr_list_response_caching;
 mod addresses;
 mod ban;
 mod connections;
+mod eviction;
 mod peer_types;
 mod ping;
 mod utils;
diff --git a/p2p/src/peer_manager/tests/utils.rs b/p2p/src/peer_manager/tests/utils.rs
index 2030a822e8..9ae00259d4 100644
--- a/p2p/src/peer_manager/tests/utils.rs
+++ b/p2p/src/peer_manager/tests/utils.rs
@@ -13,13 +13,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::time::Duration;
+use std::{collections::BTreeSet, time::Duration};
 
 use common::{chain::ChainConfig, primitives::user_agent::mintlayer_core_user_agent};
+use logging::log;
 use tokio::sync::mpsc;
 
-use p2p_test_utils::P2pBasicTestTimeGetter;
-use p2p_types::PeerId;
+use p2p_test_utils::{wait_for_recv, P2pBasicTestTimeGetter};
+use p2p_types::{services::Service, socket_address::SocketAddress, PeerId};
 use test_utils::assert_matches_return_val;
 
 use crate::{
@@ -30,6 +31,7 @@ use crate::{
         types::PeerInfo,
     },
     testing_utils::TEST_PROTOCOL_VERSION,
+    tests::helpers::PeerManagerNotification,
 };
 
 pub fn cmd_to_peer_man_msg(cmd: Command) -> (PeerId, PeerManagerMessage) {
@@ -62,7 +64,7 @@ pub async fn recv_command_advance_time(
     }
 }
 
-pub fn make_peer_info(peer_id: PeerId, chain_config: &ChainConfig) -> PeerInfo {
+pub fn make_full_relay_peer_info(peer_id: PeerId, chain_config: &ChainConfig) -> PeerInfo {
     PeerInfo {
         peer_id,
         protocol_version: TEST_PROTOCOL_VERSION,
@@ -72,3 +74,41 @@ pub fn make_peer_info(peer_id: PeerId, chain_config: &ChainConfig) -> PeerInfo {
         common_services: NodeType::Full.into(),
     }
 }
+
+pub fn make_block_relay_peer_info(peer_id: PeerId, chain_config: &ChainConfig) -> PeerInfo {
+    PeerInfo {
+        peer_id,
+        protocol_version: TEST_PROTOCOL_VERSION,
+        network: *chain_config.magic_bytes(),
+        software_version: *chain_config.software_version(),
+        user_agent: mintlayer_core_user_agent(),
+        common_services: [Service::Blocks].as_slice().into(),
+    }
+}
+
+pub fn expect_connect_cmd(cmd: &Command, addresses: &mut BTreeSet<SocketAddress>) -> SocketAddress {
+    match cmd {
+        Command::Connect {
+            address,
+            local_services_override: _,
+        } => {
+            log::debug!("Connection attempt to {address} detected");
+            assert!(addresses.contains(address));
+            addresses.remove(address);
+            *address
+        }
+        cmd => {
+            panic!("Unexpected command received: {cmd:?}");
+        }
+    }
+}
+
+pub async fn wait_for_heartbeat(
+    peer_mgr_notification_receiver: &mut mpsc::UnboundedReceiver<PeerManagerNotification>,
+) {
+    wait_for_recv(
+        peer_mgr_notification_receiver,
+        &PeerManagerNotification::Heartbeat,
+    )
+    .await;
+}
diff --git a/p2p/src/peer_manager_event.rs b/p2p/src/peer_manager_event.rs
index c1500290df..0454088e00 100644
--- a/p2p/src/peer_manager_event.rs
+++ b/p2p/src/peer_manager_event.rs
@@ -24,7 +24,7 @@ use p2p_types::{
 
 use crate::{
     interface::types::ConnectedPeer, peer_manager::PeerManagerQueryInterface,
-    types::peer_id::PeerId, utils::oneshot_nofail,
+    sync::sync_status::PeerBlockSyncStatus, types::peer_id::PeerId, utils::oneshot_nofail,
 };
 
 #[derive(Debug)]
@@ -89,6 +89,12 @@ pub enum PeerManagerEvent {
         txid: Id<Transaction>,
     },
 
+    /// PeerBlockSyncStatus has changed for the specified peer.
+    PeerBlockSyncStatusUpdate {
+        peer_id: PeerId,
+        new_status: PeerBlockSyncStatus,
+    },
+
     AddReserved(IpOrSocketAddress, oneshot_nofail::Sender<crate::Result<()>>),
 
     RemoveReserved(IpOrSocketAddress, oneshot_nofail::Sender<crate::Result<()>>),
diff --git a/p2p/src/sync/mod.rs b/p2p/src/sync/mod.rs
index 05466862ef..be1c9e0077 100644
--- a/p2p/src/sync/mod.rs
+++ b/p2p/src/sync/mod.rs
@@ -17,9 +17,10 @@
 //! to block announcement from peers and the announcement of blocks produced by this node).
 
 mod chainstate_handle;
+mod peer_activity;
 mod peer_common;
 mod peer_v2;
-mod types;
+pub mod sync_status;
 
 use std::collections::HashMap;
 
diff --git a/p2p/src/sync/types.rs b/p2p/src/sync/peer_activity.rs
similarity index 92%
rename from p2p/src/sync/types.rs
rename to p2p/src/sync/peer_activity.rs
index 4647dfcaf4..2b0f195c38 100644
--- a/p2p/src/sync/types.rs
+++ b/p2p/src/sync/peer_activity.rs
@@ -30,11 +30,11 @@ impl PeerActivity {
         }
     }
 
-    pub fn expecting_headers_since(&mut self) -> Option<Time> {
+    pub fn expecting_headers_since(&self) -> Option<Time> {
         self.expecting_headers_since
     }
 
-    pub fn expecting_blocks_since(&mut self) -> Option<Time> {
+    pub fn expecting_blocks_since(&self) -> Option<Time> {
         self.expecting_blocks_since
     }
 
diff --git a/p2p/src/sync/peer_v2/block_manager.rs b/p2p/src/sync/peer_v2/block_manager.rs
index 2bb30e3deb..cd529d0a46 100644
--- a/p2p/src/sync/peer_v2/block_manager.rs
+++ b/p2p/src/sync/peer_v2/block_manager.rs
@@ -45,8 +45,9 @@ use crate::{
     peer_manager_event::PeerDisconnectionDbAction,
     sync::{
         chainstate_handle::ChainstateHandle,
+        peer_activity::PeerActivity,
         peer_common::{choose_peers_best_block, handle_message_processing_result},
-        types::PeerActivity,
+        sync_status::PeerBlockSyncStatus,
         LocalEvent,
     },
     types::peer_id::PeerId,
@@ -163,13 +164,18 @@ where
 
     async fn main_loop(&mut self) -> Result<()> {
         let stalling_timeout = *self.p2p_config.sync_stalling_timeout;
+        let last_sync_status = self.get_sync_status();
 
         if self.common_services.has_service(Service::Blocks) {
             log::debug!("[peer id = {}] Asking for headers initially", self.id());
             self.request_headers().await?;
         }
 
+        self.handle_sync_status_change(&last_sync_status)?;
+
         loop {
+            let last_sync_status = self.get_sync_status();
+
             tokio::select! {
                 message = self.sync_msg_receiver.recv() => {
                     let message = message.ok_or(P2pError::ChannelClosed)?;
@@ -191,11 +197,32 @@ where
                     if self.peer_activity.earliest_expected_activity_time().is_some() => {}
             }
 
+            self.handle_sync_status_change(&last_sync_status)?;
+
             // Run on each loop iteration, so it's easier to test
             self.handle_stalling_interval().await;
         }
     }
 
+    fn get_sync_status(&self) -> PeerBlockSyncStatus {
+        PeerBlockSyncStatus {
+            expecting_blocks_since: self.peer_activity.expecting_blocks_since(),
+        }
+    }
+
+    fn handle_sync_status_change(&self, prev_sync_status: &PeerBlockSyncStatus) -> Result<()> {
+        let cur_sync_status = self.get_sync_status();
+
+        if cur_sync_status != *prev_sync_status {
+            self.peer_mgr_event_sender.send(PeerManagerEvent::PeerBlockSyncStatusUpdate {
+                peer_id: self.id(),
+                new_status: cur_sync_status,
+            })?;
+        }
+
+        Ok(())
+    }
+
     fn send_message(&mut self, message: BlockSyncMessage) -> Result<()> {
         self.messaging_handle.send_block_sync_message(self.id(), message)
     }
@@ -679,13 +706,7 @@ where
             block_id
         );
 
-        // Clear the block expectation time, because we've received a block.
-        // The code below will set it again if needed.
-        self.peer_activity.set_expecting_blocks_since(None);
-
-        if self.incoming.requested_blocks.front().is_some_and(|id| id == &block.get_id()) {
-            self.incoming.requested_blocks.pop_front();
-        } else {
+        if self.incoming.requested_blocks.front() != Some(&block.get_id()) {
             let idx = self.incoming.requested_blocks.iter().position(|id| id == &block.get_id());
             // Note: we treat wrongly ordered blocks in the same way as unsolicited ones, i.e.
             // we don't remove their ids from the list.
@@ -707,6 +728,14 @@ where
             }
         }
 
+        self.incoming.requested_blocks.pop_front();
+
+        if self.incoming.requested_blocks.is_empty() {
+            self.peer_activity.set_expecting_blocks_since(None);
+        } else {
+            self.peer_activity.set_expecting_blocks_since(Some(self.time_getter.get_time()));
+        }
+
         let block = self.chainstate_handle.call(|c| Ok(c.preliminary_block_check(block)?)).await?;
 
         // Process the block and also determine the new value for peers_best_block_that_we_have.
@@ -768,9 +797,6 @@ where
                 // Download remaining blocks.
                 self.request_blocks(headers)?;
             }
-        } else {
-            // We expect additional blocks from the peer, update the timestamp.
-            self.peer_activity.set_expecting_blocks_since(Some(self.time_getter.get_time()));
         }
 
         Ok(())
diff --git a/p2p/src/sync/sync_status.rs b/p2p/src/sync/sync_status.rs
new file mode 100644
index 0000000000..37e5168eda
--- /dev/null
+++ b/p2p/src/sync/sync_status.rs
@@ -0,0 +1,31 @@
+// Copyright (c) 2021-2024 RBB S.r.l
+// opensource@mintlayer.org
+// SPDX-License-Identifier: MIT
+// Licensed under the MIT License;
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://github.com/mintlayer/mintlayer-core/blob/master/LICENSE
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use common::primitives::time::Time;
+
+/// Certain information about the current state of block syncing that other parts of p2p
+/// (namely, the peer manager) may be interested in.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PeerBlockSyncStatus {
+    pub expecting_blocks_since: Option<Time>,
+}
+
+impl PeerBlockSyncStatus {
+    pub fn new() -> Self {
+        Self {
+            expecting_blocks_since: None,
+        }
+    }
+}
diff --git a/p2p/src/sync/tests/block_response.rs b/p2p/src/sync/tests/block_response.rs
index 9efdc3806c..e106bd8a09 100644
--- a/p2p/src/sync/tests/block_response.rs
+++ b/p2p/src/sync/tests/block_response.rs
@@ -38,7 +38,7 @@ use crate::{
     },
     testing_utils::{for_each_protocol_version, test_p2p_config},
     types::peer_id::PeerId,
-    P2pConfig, P2pError,
+    P2pConfig, P2pError, PeerManagerEvent,
 };
 
 #[tracing::instrument(skip(seed))]
@@ -227,16 +227,19 @@ async fn block_responses_in_wrong_order(#[case] seed: Seed) {
                     expected_indices.pop_front();
 
                     let expected_block_id = blocks[shuffled_index].get_id();
-                    node.receive_peer_manager_events(BTreeSet::from_iter(
-                        [
-                            PeerManagerEventDesc::NewTipReceived {
-                                peer_id: peer.get_id(),
-                                block_id: expected_block_id,
-                            },
-                            PeerManagerEventDesc::NewChainstateTip(expected_block_id),
-                        ]
-                        .into_iter(),
-                    ))
+                    node.receive_or_ignore_peer_manager_events(
+                        BTreeSet::from_iter(
+                            [
+                                PeerManagerEventDesc::NewTipReceived {
+                                    peer_id: peer.get_id(),
+                                    block_id: expected_block_id,
+                                },
+                                PeerManagerEventDesc::NewChainstateTip(expected_block_id),
+                            ]
+                            .into_iter(),
+                        ),
+                        |event| matches!(event, PeerManagerEvent::PeerBlockSyncStatusUpdate { .. }),
+                    )
                     .await;
                 } else {
                     let (adjusted_peer, score) = node.receive_adjust_peer_score_event().await;
diff --git a/p2p/src/sync/tests/helpers/mod.rs b/p2p/src/sync/tests/helpers/mod.rs
index 301a4d6489..65b84fd677 100644
--- a/p2p/src/sync/tests/helpers/mod.rs
+++ b/p2p/src/sync/tests/helpers/mod.rs
@@ -254,25 +254,43 @@ impl TestNode {
         expect_no_recv!(self.error_receiver);
     }
 
-    /// Receives the `AdjustPeerScore` event from the peer manager.
+    /// Expect an `AdjustPeerScore` event from the peer manager.
+    /// PeerBlockSyncStatusUpdate events are ignored.
     pub async fn receive_adjust_peer_score_event(&mut self) -> (PeerId, u32) {
-        match self.peer_manager_event_receiver.recv().await.unwrap() {
-            PeerManagerEvent::AdjustPeerScore(peer, score, sender) => {
-                sender.send(Ok(()));
-                (peer, score)
+        let future = async {
+            loop {
+                match self.peer_manager_event_receiver.recv().await.unwrap() {
+                    PeerManagerEvent::AdjustPeerScore(peer, score, sender) => {
+                        sender.send(Ok(()));
+                        break (peer, score);
+                    }
+                    PeerManagerEvent::PeerBlockSyncStatusUpdate { .. } => {}
+                    e => panic!("Expected PeerManagerEvent::Disconnect, received: {e:?}"),
+                }
             }
-            e => panic!("Unexpected peer manager event: {e:?}"),
-        }
+        };
+
+        expect_future_val!(future)
     }
 
+    /// Expect a `Disconnect` event from the peer manager.
+    /// PeerBlockSyncStatusUpdate events are ignored.
     pub async fn receive_disconnect_peer_event(&mut self, id: PeerId) {
-        match self.peer_manager_event_receiver.recv().await.unwrap() {
-            PeerManagerEvent::Disconnect(peer_id, _peerdb_action, sender) => {
-                assert_eq!(id, peer_id);
-                sender.send(Ok(()));
+        let future = async {
+            loop {
+                match self.peer_manager_event_receiver.recv().await.unwrap() {
+                    PeerManagerEvent::Disconnect(peer_id, _peerdb_action, sender) => {
+                        assert_eq!(id, peer_id);
+                        sender.send(Ok(()));
+                        break;
+                    }
+                    PeerManagerEvent::PeerBlockSyncStatusUpdate { .. } => {}
+                    e => panic!("Expected PeerManagerEvent::Disconnect, received: {e:?}"),
+                }
             }
-            e => panic!("Expected PeerManagerEvent::Disconnect, received: {e:?}"),
-        }
+        };
+
+        expect_future_val!(future);
     }
 
     pub async fn receive_peer_manager_events(
@@ -280,7 +298,7 @@ impl TestNode {
         mut events: BTreeSet<PeerManagerEventDesc>,
     ) {
         while !events.is_empty() {
-            let event = self.peer_manager_event_receiver.recv().await.unwrap();
+            let event = expect_recv!(self.peer_manager_event_receiver);
             assert!(
                 events.remove(&(&event).into()),
                 "Unexpected peer manager event: {event:?}"
@@ -288,6 +306,22 @@ impl TestNode {
         }
     }
 
+    pub async fn receive_or_ignore_peer_manager_events(
+        &mut self,
+        mut events: BTreeSet<PeerManagerEventDesc>,
+        should_ignore: impl Fn(&PeerManagerEvent) -> bool,
+    ) {
+        while !events.is_empty() {
+            let event = expect_recv!(self.peer_manager_event_receiver);
+            if !should_ignore(&event) {
+                assert!(
+                    events.remove(&(&event).into()),
+                    "Unexpected peer manager event: {event:?}"
+                );
+            }
+        }
+    }
+
     pub async fn assert_no_disconnect_peer_event(&mut self, id: PeerId) {
         time::timeout(SHORT_TIMEOUT, async {
             loop {
@@ -303,7 +337,8 @@ impl TestNode {
         .unwrap_err();
     }
 
-    /// Panics if there is an event from the peer manager (except for the NewTipReceived/NewChainstateTip/NewValidTransactionReceived messages)
+    /// Panics if there is an event from the peer manager (except for "informational" messages,
+    /// like NewTipReceived/NewChainstateTip etc).
     // TODO: Rename the function
     pub async fn assert_no_peer_manager_event(&mut self) {
         time::timeout(SHORT_TIMEOUT, async {
@@ -326,7 +361,8 @@ impl TestNode {
                     }
                     PeerManagerEvent::NewTipReceived { .. }
                     | PeerManagerEvent::NewChainstateTip(_)
-                    | PeerManagerEvent::NewValidTransactionReceived { .. } => {
+                    | PeerManagerEvent::NewValidTransactionReceived { .. }
+                    | PeerManagerEvent::PeerBlockSyncStatusUpdate { .. } => {
                         // Ignored
                     }
                 }
@@ -564,7 +600,10 @@ pub enum PeerManagerEventDesc {
     GetPeerCount,
     GetBindAddresses,
     GetConnectedPeers,
-    AdjustPeerScore(PeerId, u32),
+    AdjustPeerScore {
+        peer_id: PeerId,
+        score: u32,
+    },
     NewTipReceived {
         peer_id: PeerId,
         block_id: Id<Block>,
@@ -574,6 +613,13 @@ pub enum PeerManagerEventDesc {
         peer_id: PeerId,
         txid: Id<Transaction>,
     },
+    PeerBlockSyncStatusUpdate {
+        peer_id: PeerId,
+        // Note: we don't include PeerBlockSyncStatus here, because the purpose of
+        // PeerManagerEventDesc is to be able to easily form a set of expected values and those
+        // values must be easy to predict. Currently, PeerBlockSyncStatus only contains a Time
+        // value, which may be hard to predict, depending on the test.
+    },
     AddReserved(IpOrSocketAddress),
     RemoveReserved(IpOrSocketAddress),
     ListBanned,
@@ -593,7 +639,10 @@ impl From<&PeerManagerEvent> for PeerManagerEventDesc {
             PeerManagerEvent::GetBindAddresses(_) => PeerManagerEventDesc::GetBindAddresses,
             PeerManagerEvent::GetConnectedPeers(_) => PeerManagerEventDesc::GetConnectedPeers,
             PeerManagerEvent::AdjustPeerScore(peer_id, score, _) => {
-                PeerManagerEventDesc::AdjustPeerScore(*peer_id, *score)
+                PeerManagerEventDesc::AdjustPeerScore {
+                    peer_id: *peer_id,
+                    score: *score,
+                }
             }
             PeerManagerEvent::NewTipReceived { peer_id, block_id } => {
                 PeerManagerEventDesc::NewTipReceived {
@@ -610,6 +659,10 @@ impl From<&PeerManagerEvent> for PeerManagerEventDesc {
                     txid: *txid,
                 }
             }
+            PeerManagerEvent::PeerBlockSyncStatusUpdate {
+                peer_id,
+                new_status: _,
+            } => PeerManagerEventDesc::PeerBlockSyncStatusUpdate { peer_id: *peer_id },
             PeerManagerEvent::AddReserved(addr, _) => {
                 PeerManagerEventDesc::AddReserved(addr.clone())
             }
diff --git a/p2p/src/sync/tests/helpers/test_node_group.rs b/p2p/src/sync/tests/helpers/test_node_group.rs
index 56c7946e2c..0b2fa92d84 100644
--- a/p2p/src/sync/tests/helpers/test_node_group.rs
+++ b/p2p/src/sync/tests/helpers/test_node_group.rs
@@ -304,7 +304,7 @@ impl TestNodeGroup {
         self.prevent_peer_manager_events = set;
     }
 
-    /// NewTipReceived/NewChainstateTip/NewValidTransactionReceived messages are ignored
+    /// The "informational" messages like NewTipReceived/NewChainstateTip etc are ignored.
     // TODO: Rename the function
     fn assert_no_peer_manager_events_if_needed(&mut self) {
         if self.prevent_peer_manager_events {
@@ -327,7 +327,8 @@ impl TestNodeGroup {
                         }
                         PeerManagerEvent::NewTipReceived { .. }
                         | PeerManagerEvent::NewChainstateTip(_)
-                        | PeerManagerEvent::NewValidTransactionReceived { .. } => {
+                        | PeerManagerEvent::NewValidTransactionReceived { .. }
+                        | PeerManagerEvent::PeerBlockSyncStatusUpdate { .. } => {
                             // Ignored
                         }
                     }