diff --git a/crates/transaction-pool/src/pool/listener.rs b/crates/transaction-pool/src/pool/listener.rs
index f3ff53545..994c1fac5 100644
--- a/crates/transaction-pool/src/pool/listener.rs
+++ b/crates/transaction-pool/src/pool/listener.rs
@@ -116,10 +116,15 @@ impl PoolEventBroadcast {
 
         if let Some(replaced) = replaced {
             // notify listeners that this transaction was replaced
-            self.broadcast_event(replaced, TransactionEvent::Replaced(*tx));
+            self.replaced(replaced, tx);
         }
     }
 
+    /// Notify listeners about a transaction that was replaced.
+    pub(crate) fn replaced(&mut self, tx: &TxHash, replaced_by: &TxHash) {
+        self.broadcast_event(tx, TransactionEvent::Replaced(*replaced_by));
+    }
+
     /// Notify listeners about a transaction that was added to the queued pool.
     pub(crate) fn queued(&mut self, tx: &TxHash) {
         self.broadcast_event(tx, TransactionEvent::Queued);
diff --git a/crates/transaction-pool/src/pool/mod.rs b/crates/transaction-pool/src/pool/mod.rs
index 0d6b0983f..23590d741 100644
--- a/crates/transaction-pool/src/pool/mod.rs
+++ b/crates/transaction-pool/src/pool/mod.rs
@@ -415,14 +415,17 @@ where
 
         match tx {
             AddedTransaction::Pending(tx) => {
-                let AddedPendingTransaction { transaction, promoted, discarded, .. } = tx;
+                let AddedPendingTransaction { transaction, promoted, discarded, replaced } = tx;
 
-                listener.pending(transaction.hash(), None);
+                listener.pending(transaction.hash(), replaced.as_ref().map(|tx| tx.hash()));
                 promoted.iter().for_each(|tx| listener.pending(tx, None));
                 discarded.iter().for_each(|tx| listener.discarded(tx));
             }
-            AddedTransaction::Parked { transaction, .. } => {
+            AddedTransaction::Parked { transaction, replaced, .. } => {
                 listener.queued(transaction.hash());
+                if let Some(replaced) = replaced {
+                    listener.replaced(replaced.hash(), transaction.hash());
+                }
             }
         }
     }
@@ -532,6 +535,8 @@ impl<V: TransactionValidator, T: TransactionOrdering> fmt::Debug for PoolInner<V
 pub struct AddedPendingTransaction<T: PoolTransaction> {
     /// Inserted transaction.
     transaction: Arc<ValidPoolTransaction<T>>,
+    /// Replaced transaction.
+    replaced: Option<Arc<ValidPoolTransaction<T>>>,
     /// transactions promoted to the ready queue
     promoted: Vec<TxHash>,
     /// transaction that failed and became discarded
@@ -548,6 +553,8 @@ pub enum AddedTransaction<T: PoolTransaction> {
     Parked {
         /// Inserted transaction.
         transaction: Arc<ValidPoolTransaction<T>>,
+        /// Replaced transaction.
+        replaced: Option<Arc<ValidPoolTransaction<T>>>,
         /// The subpool it was moved to.
         subpool: SubPool,
     },
@@ -577,7 +584,7 @@ impl<T: PoolTransaction> AddedTransaction<T> {
             AddedTransaction::Pending(tx) => {
                 NewTransactionEvent { subpool: SubPool::Pending, transaction: tx.transaction }
             }
-            AddedTransaction::Parked { transaction, subpool } => {
+            AddedTransaction::Parked { transaction, subpool, .. } => {
                 NewTransactionEvent { transaction, subpool }
             }
         }
diff --git a/crates/transaction-pool/src/pool/txpool.rs b/crates/transaction-pool/src/pool/txpool.rs
index 4368a240f..71b5590a6 100644
--- a/crates/transaction-pool/src/pool/txpool.rs
+++ b/crates/transaction-pool/src/pool/txpool.rs
@@ -314,20 +314,22 @@ impl<T: TransactionOrdering> TxPool<T> {
 
         match self.all_transactions.insert_tx(tx, on_chain_balance, on_chain_nonce) {
             Ok(InsertOk { transaction, move_to, replaced_tx, updates, .. }) => {
-                self.add_new_transaction(transaction.clone(), replaced_tx, move_to);
+                self.add_new_transaction(transaction.clone(), replaced_tx.clone(), move_to);
                 // Update inserted transactions metric
                 self.metrics.inserted_transactions.increment(1);
                 let UpdateOutcome { promoted, discarded } = self.process_updates(updates);
 
                 // This transaction was moved to the pending pool.
+                let replaced = replaced_tx.map(|(tx, _)| tx);
                 let res = if move_to.is_pending() {
                     AddedTransaction::Pending(AddedPendingTransaction {
                         transaction,
                         promoted,
                         discarded,
+                        replaced,
                     })
                 } else {
-                    AddedTransaction::Parked { transaction, subpool: move_to }
+                    AddedTransaction::Parked { transaction, subpool: move_to, replaced }
                 };
 
                 Ok(res)