diff --git a/test/functional/interface_usdt_mempool.py b/test/functional/interface_usdt_mempool.py
new file mode 100755
index 0000000000..35c2930d03
--- /dev/null
+++ b/test/functional/interface_usdt_mempool.py
@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+# Copyright (c) 2022 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+"""  Tests the mempool:* tracepoint API interface.
+     See https://github.com/dashpay/dash/blob/develop/doc/tracing.md#context-mempool
+"""
+
+import ctypes
+# Test will be skipped if we don't have bcc installed
+try:
+    from bcc import BPF, USDT  # type: ignore[import]
+except ImportError:
+    pass
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+from test_framework.wallet import MiniWallet
+
+
+MEMPOOL_TRACEPOINTS_PROGRAM = """
+#include <uapi/linux/ptrace.h>
+
+#define TXID_LENGTH 32
+#define MAX_REMOVAL_REASON_LENGTH 9
+
+struct added_transaction
+{
+    u8     txid[TXID_LENGTH];
+    u64    vsize;
+    s64    fee;
+};
+
+struct removed_transaction
+{
+    u8     txid[TXID_LENGTH];
+    char   removal_reason[MAX_REMOVAL_REASON_LENGTH];
+    u64    vsize;
+    s64    fee;
+    u64    entry_time;
+};
+
+struct replaced_transaction
+{
+    u8     txid[TXID_LENGTH];
+    u64    vsize;
+    s64    fee;
+    u64    entry_time;
+};
+
+struct rejected_transaction
+{
+    u8     txid[TXID_LENGTH];
+    char   removal_reason[MAX_REMOVAL_REASON_LENGTH];
+};
+
+BPF_PERF_OUTPUT(added_events);
+int trace_added(struct pt_regs *ctx) {
+  struct added_transaction added = {};
+  bpf_usdt_readarg_p(1, ctx, &added.txid, TXID_LENGTH);
+  bpf_usdt_readarg(2, ctx, &added.vsize);
+  bpf_usdt_readarg(3, ctx, &added.fee);
+  added_events.perf_submit(ctx, &added, sizeof(added));
+  return 0;
+}
+
+BPF_PERF_OUTPUT(removed_events);
+int trace_removed(struct pt_regs *ctx) {
+  struct removed_transaction removed = {};
+  bpf_usdt_readarg_p(1, ctx, &removed.txid, TXID_LENGTH);
+  bpf_usdt_readarg_p(2, ctx, &removed.removal_reason, MAX_REMOVAL_REASON_LENGTH);
+  bpf_usdt_readarg(3, ctx, &removed.vsize);
+  bpf_usdt_readarg(4, ctx, &removed.fee);
+  bpf_usdt_readarg(5, ctx, &removed.entry_time);
+  removed_events.perf_submit(ctx, &removed, sizeof(removed));
+  return 0;
+}
+
+BPF_PERF_OUTPUT(replaced_events);
+int trace_replaced(struct pt_regs *ctx) {
+  struct replaced_transaction replaced = {};
+  bpf_usdt_readarg_p(1, ctx, &replaced.txid, TXID_LENGTH);
+  bpf_usdt_readarg(2, ctx, &replaced.vsize);
+  bpf_usdt_readarg(3, ctx, &replaced.fee);
+  bpf_usdt_readarg(4, ctx, &replaced.entry_time);
+  replaced_events.perf_submit(ctx, &replaced, sizeof(replaced));
+  return 0;
+}
+
+BPF_PERF_OUTPUT(rejected_events);
+int trace_rejected(struct pt_regs *ctx) {
+  struct rejected_transaction rejected = {};
+  bpf_usdt_readarg_p(1, ctx, &rejected.txid, TXID_LENGTH);
+  bpf_usdt_readarg_p(2, ctx, &rejected.removal_reason, MAX_REMOVAL_REASON_LENGTH);
+  rejected_events.perf_submit(ctx, &rejected, sizeof(rejected));
+  return 0;
+}
+
+"""
+
+
+class MempoolTracepointTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_platform_not_linux()
+        self.skip_if_no_bitcoind_tracepoints()
+        self.skip_if_no_python_bcc()
+        self.skip_if_no_bpf_permissions()
+
+    def run_test(self):
+        self.test_mempool_added()
+        self.test_mempool_removed()
+        self.test_mempool_replaced()
+        self.test_mempool_rejected()
+
+    def test_mempool_added(self):
+        """Tests the mempool:added tracepoint API."""
+        self.log.info("Testing the mempool:added tracepoint API")
+
+        self.log.info("Hooking into mempool:added tracepoint...")
+        node = self.nodes[0]
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:added", fn_name="trace_added")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_added_event(_, data, __):
+            events.append(bpf["added_events"].event(data))
+
+        bpf["added_events"].open_perf_buffer(handle_added_event)
+
+        wallet = MiniWallet(node)
+        self.generate(wallet, 1)
+
+        self.log.info("Sending a transaction...")
+        events = []
+        tx = wallet.send_self_transfer(from_node=node)
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info("Checking the mempool:added event was fired...")
+        assert_equal(len(events), 1)
+        event = events[0]
+        self.verify_transaction_event(event, tx)
+
+        bpf.cleanup()
+
+    def test_mempool_removed(self):
+        """Tests the mempool:removed tracepoint API."""
+        self.log.info("Testing the mempool:removed tracepoint API")
+
+        self.log.info("Detecting mempool:removed event...")
+        node = self.nodes[0]
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:removed", fn_name="trace_removed")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_removed_event(_, data, __):
+            events.append(bpf["removed_events"].event(data))
+
+        bpf["removed_events"].open_perf_buffer(handle_removed_event)
+
+        wallet = MiniWallet(node)
+        self.generate(wallet, 1)
+
+        self.log.info("Sending a transaction and mining a block...")
+        events = []
+        tx = wallet.send_self_transfer(from_node=node)
+        self.generate(node, 1)
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info(
+            "Checking the mempool:removed event was fired for the transaction included in the block...")
+        assert_equal(len(events), 1)
+        event = events[0]
+        self.verify_transaction_event(event, tx)
+        assert_equal(event.removal_reason.decode("utf-8"), "block")
+
+        bpf.cleanup()
+
+    def test_mempool_replaced(self):
+        """Tests the mempool:replaced tracepoint API."""
+        self.log.info("Testing the mempool:replaced tracepoint API")
+
+        self.log.info("Hooking into mempool:replaced tracepoint...")
+        node = self.nodes[0]
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:replaced", fn_name="trace_replaced")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_replaced_event(_, data, __):
+            events.append(bpf["replaced_events"].event(data))
+
+        bpf["replaced_events"].open_perf_buffer(handle_replaced_event)
+
+        wallet = MiniWallet(node)
+        self.generate(wallet, 1)
+
+        # Spend the same output, but with a smaller fee
+        self.log.info("Sending a transaction with low fees...")
+        utxo = wallet.get_utxo()
+        tx_replaced = wallet.send_self_transfer(
+            from_node=node, utxo_to_spend=utxo, fee_rate=1)
+
+        self.log.info("Sending a transaction that replaces the low fee transaction...")
+        events = []
+        wallet.send_self_transfer(
+            from_node=node, utxo_to_spend=utxo, fee_rate=2)
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info("Checking the mempool:replaced event was fired...")
+        assert_equal(len(events), 1)
+        event = events[0]
+        self.verify_transaction_event(event, tx_replaced)
+
+        bpf.cleanup()
+
+    def test_mempool_rejected(self):
+        """Tests the mempool:rejected tracepoint API."""
+        self.log.info("Testing the mempool:rejected tracepoint API")
+
+        # Restart node with higher mempool limit
+        node = self.nodes[0]
+        self.restart_node(0, ["-limitdescendantsize=1"])
+
+        self.log.info("Hooking into mempool:rejected tracepoint...")
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:rejected", fn_name="trace_rejected")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_rejected_event(_, data, __):
+            events.append(bpf["rejected_events"].event(data))
+
+        bpf["rejected_events"].open_perf_buffer(handle_rejected_event)
+
+        wallet = MiniWallet(node)
+        self.generate(wallet, 1)
+
+        self.log.info("Creating a parent transaction...")
+        parent_tx = wallet.send_self_transfer(from_node=node)
+
+        self.log.info("Creating a child transaction...")
+        events = []
+        wallet.send_self_transfer(from_node=node, utxo_to_spend=parent_tx["new_utxo"])
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info("Checking that the mempool:rejected event was fired for the child...")
+        assert_equal(len(events), 1)
+        event = events[0]
+        assert_equal(event.removal_reason.decode("utf-8"), "too-long-mempool-chain")
+
+        bpf.cleanup()
+        self.restart_node(0)
+
+    def verify_transaction_event(self, event, tx):
+        """Helper to verify transaction event."""
+        assert_equal(bytes(event.txid)[::-1].hex(), tx["txid"])
\ No newline at end of file

diff --git a/test/functional/interface_usdt_mempool.py b/test/functional/interface_usdt_mempool.py
new file mode 100644
index 0000000000..0168d9f916
--- /dev/null
+++ b/test/functional/interface_usdt_mempool.py
@@ -0,0 +1,325 @@
+#\!/usr/bin/env python3
+# Copyright (c) 2022 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+"""  Tests the mempool:* tracepoint API interface.
+     See https://github.com/bitcoin/bitcoin/blob/master/doc/tracing.md#context-mempool
+"""
+
+from decimal import Decimal
+
+# Test will be skipped if we don't have bcc installed
+try:
+    from bcc import BPF, USDT  # type: ignore[import]
+except ImportError:
+    pass
+
+from test_framework.blocktools import COINBASE_MATURITY
+from test_framework.messages import COIN, DEFAULT_MEMPOOL_EXPIRY_HOURS
+from test_framework.p2p import P2PDataStore
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+from test_framework.wallet import MiniWallet
+
+MEMPOOL_TRACEPOINTS_PROGRAM = """
+# include <uapi/linux/ptrace.h>
+
+// The longest rejection reason is 118 chars and is generated in case of SCRIPT_ERR_EVAL_FALSE by
+// strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError()))
+#define MAX_REJECT_REASON_LENGTH        118
+// The longest string returned by RemovalReasonToString() is 'sizelimit'
+#define MAX_REMOVAL_REASON_LENGTH       9
+#define HASH_LENGTH                     32
+
+struct added_event
+{
+  u8    hash[HASH_LENGTH];
+  s32   vsize;
+  s64   fee;
+};
+
+struct removed_event
+{
+  u8    hash[HASH_LENGTH];
+  char  reason[MAX_REMOVAL_REASON_LENGTH];
+  s32   vsize;
+  s64   fee;
+  u64   entry_time;
+};
+
+struct rejected_event
+{
+  u8    hash[HASH_LENGTH];
+  char  reason[MAX_REJECT_REASON_LENGTH];
+};
+
+struct replaced_event
+{
+  u8    replaced_hash[HASH_LENGTH];
+  s32   replaced_vsize;
+  s64   replaced_fee;
+  u64   replaced_entry_time;
+  u8    replacement_hash[HASH_LENGTH];
+  s32   replacement_vsize;
+  s64   replacement_fee;
+};
+
+// BPF perf buffer to push the data to user space.
+BPF_PERF_OUTPUT(added_events);
+BPF_PERF_OUTPUT(removed_events);
+BPF_PERF_OUTPUT(rejected_events);
+BPF_PERF_OUTPUT(replaced_events);
+
+int trace_added(struct pt_regs *ctx) {
+  struct added_event added = {};
+
+  bpf_usdt_readarg_p(1, ctx, &added.hash, HASH_LENGTH);
+  bpf_usdt_readarg(2, ctx, &added.vsize);
+  bpf_usdt_readarg(3, ctx, &added.fee);
+
+  added_events.perf_submit(ctx, &added, sizeof(added));
+  return 0;
+}
+
+int trace_removed(struct pt_regs *ctx) {
+  struct removed_event removed = {};
+
+  bpf_usdt_readarg_p(1, ctx, &removed.hash, HASH_LENGTH);
+  bpf_usdt_readarg_p(2, ctx, &removed.reason, MAX_REMOVAL_REASON_LENGTH);
+  bpf_usdt_readarg(3, ctx, &removed.vsize);
+  bpf_usdt_readarg(4, ctx, &removed.fee);
+  bpf_usdt_readarg(5, ctx, &removed.entry_time);
+
+  removed_events.perf_submit(ctx, &removed, sizeof(removed));
+  return 0;
+}
+
+int trace_rejected(struct pt_regs *ctx) {
+  struct rejected_event rejected = {};
+
+  bpf_usdt_readarg_p(1, ctx, &rejected.hash, HASH_LENGTH);
+  bpf_usdt_readarg_p(2, ctx, &rejected.reason, MAX_REJECT_REASON_LENGTH);
+
+  rejected_events.perf_submit(ctx, &rejected, sizeof(rejected));
+  return 0;
+}
+
+int trace_replaced(struct pt_regs *ctx) {
+  struct replaced_event replaced = {};
+
+  bpf_usdt_readarg_p(1, ctx, &replaced.replaced_hash, HASH_LENGTH);
+  bpf_usdt_readarg(2, ctx, &replaced.replaced_vsize);
+  bpf_usdt_readarg(3, ctx, &replaced.replaced_fee);
+  bpf_usdt_readarg(4, ctx, &replaced.replaced_entry_time);
+  bpf_usdt_readarg_p(5, ctx, &replaced.replacement_hash, HASH_LENGTH);
+  bpf_usdt_readarg(6, ctx, &replaced.replacement_vsize);
+  bpf_usdt_readarg(7, ctx, &replaced.replacement_fee);
+
+  replaced_events.perf_submit(ctx, &replaced, sizeof(replaced));
+  return 0;
+}
+
+"""
+
+
+class MempoolTracepointTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.setup_clean_chain = True
+
+    def skip_test_if_missing_module(self):
+        self.skip_if_platform_not_linux()
+        self.skip_if_no_bitcoind_tracepoints()
+        self.skip_if_no_python_bcc()
+        self.skip_if_no_bpf_permissions()
+
+    def added_test(self):
+        """Add a transaction to the mempool and make sure the tracepoint returns
+        the expected txid, vsize, and fee."""
+
+        events = []
+
+        self.log.info("Hooking into mempool:added tracepoint...")
+        node = self.nodes[0]
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:added", fn_name="trace_added")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_added_event(_, data, __):
+            events.append(bpf["added_events"].event(data))
+
+        bpf["added_events"].open_perf_buffer(handle_added_event)
+
+        self.log.info("Sending transaction...")
+        fee = Decimal(31200)
+        tx = self.wallet.send_self_transfer(from_node=node, fee=fee / COIN)
+
+        self.log.info("Polling buffer...")
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info("Cleaning up mempool...")
+        self.generate(node, 1)
+
+        self.log.info("Ensuring mempool:added event was handled successfully...")
+        assert_equal(1, len(events))
+        event = events[0]
+        assert_equal(bytes(event.hash)[::-1].hex(), tx["txid"])
+        assert_equal(event.vsize, tx["tx"].get_vsize())
+        assert_equal(event.fee, fee)
+
+        bpf.cleanup()
+        self.generate(self.wallet, 1)
+
+    def removed_test(self):
+        """Expire a transaction from the mempool and make sure the tracepoint returns
+        the expected txid, expiry reason, vsize, and fee."""
+
+        events = []
+
+        self.log.info("Hooking into mempool:removed tracepoint...")
+        node = self.nodes[0]
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:removed", fn_name="trace_removed")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_removed_event(_, data, __):
+            events.append(bpf["removed_events"].event(data))
+
+        bpf["removed_events"].open_perf_buffer(handle_removed_event)
+
+        self.log.info("Sending transaction...")
+        fee = Decimal(31200)
+        tx = self.wallet.send_self_transfer(from_node=node, fee=fee / COIN)
+        txid = tx["txid"]
+
+        self.log.info("Fast-forwarding time to mempool expiry...")
+        entry_time = node.getmempoolentry(txid)["time"]
+        expiry_time = entry_time + 60 * 60 * DEFAULT_MEMPOOL_EXPIRY_HOURS + 5
+        node.setmocktime(expiry_time)
+
+        self.log.info("Triggering expiry...")
+        self.wallet.get_utxo(txid=txid)
+        self.wallet.send_self_transfer(from_node=node)
+
+        self.log.info("Polling buffer...")
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info("Ensuring mempool:removed event was handled successfully...")
+        assert_equal(1, len(events))
+        event = events[0]
+        assert_equal(bytes(event.hash)[::-1].hex(), txid)
+        assert_equal(event.reason.decode("UTF-8"), "expiry")
+        assert_equal(event.vsize, tx["tx"].get_vsize())
+        assert_equal(event.fee, fee)
+        assert_equal(event.entry_time, entry_time)
+
+        bpf.cleanup()
+        self.generate(self.wallet, 1)
+
+    def replaced_test(self):
+        """Replace one and two transactions in the mempool and make sure the tracepoint
+        returns the expected txids, vsizes, and fees."""
+
+        events = []
+
+        self.log.info("Hooking into mempool:replaced tracepoint...")
+        node = self.nodes[0]
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:replaced", fn_name="trace_replaced")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_replaced_event(_, data, __):
+            events.append(bpf["replaced_events"].event(data))
+
+        bpf["replaced_events"].open_perf_buffer(handle_replaced_event)
+
+        self.log.info("Sending RBF transaction...")
+        utxo = self.wallet.get_utxo(mark_as_spent=True)
+        original_fee = Decimal(40000)
+        original_tx = self.wallet.send_self_transfer(
+            from_node=node, utxo_to_spend=utxo, fee=original_fee / COIN
+        )
+        entry_time = node.getmempoolentry(original_tx["txid"])["time"]
+
+        self.log.info("Sending replacement transaction...")
+        replacement_fee = Decimal(45000)
+        replacement_tx = self.wallet.send_self_transfer(
+            from_node=node, utxo_to_spend=utxo, fee=replacement_fee / COIN
+        )
+
+        self.log.info("Polling buffer...")
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info("Ensuring mempool:replaced event was handled successfully...")
+        assert_equal(1, len(events))
+        event = events[0]
+        assert_equal(bytes(event.replaced_hash)[::-1].hex(), original_tx["txid"])
+        assert_equal(event.replaced_vsize, original_tx["tx"].get_vsize())
+        assert_equal(event.replaced_fee, original_fee)
+        assert_equal(event.replaced_entry_time, entry_time)
+        assert_equal(bytes(event.replacement_hash)[::-1].hex(), replacement_tx["txid"])
+        assert_equal(event.replacement_vsize, replacement_tx["tx"].get_vsize())
+        assert_equal(event.replacement_fee, replacement_fee)
+
+        bpf.cleanup()
+        self.generate(self.wallet, 1)
+
+    def rejected_test(self):
+        """Create an invalid transaction and make sure the tracepoint returns
+        the expected txid, rejection reason, peer id, and peer address."""
+
+        events = []
+
+        self.log.info("Adding P2P connection...")
+        node = self.nodes[0]
+        node.add_p2p_connection(P2PDataStore())
+
+        self.log.info("Hooking into mempool:rejected tracepoint...")
+        ctx = USDT(pid=node.process.pid)
+        ctx.enable_probe(probe="mempool:rejected", fn_name="trace_rejected")
+        bpf = BPF(text=MEMPOOL_TRACEPOINTS_PROGRAM, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
+
+        def handle_rejected_event(_, data, __):
+            events.append(bpf["rejected_events"].event(data))
+
+        bpf["rejected_events"].open_perf_buffer(handle_rejected_event)
+
+        self.log.info("Sending invalid transaction...")
+        tx = self.wallet.create_self_transfer(fee_rate=Decimal(0))
+        node.p2ps[0].send_txs_and_test([tx["tx"]], node, success=False)
+
+        self.log.info("Polling buffer...")
+        bpf.perf_buffer_poll(timeout=200)
+
+        self.log.info("Ensuring mempool:rejected event was handled successfully...")
+        assert_equal(1, len(events))
+        event = events[0]
+        assert_equal(bytes(event.hash)[::-1].hex(), tx["tx"].hash)
+        # The next test is already known to fail, so disable it to avoid
+        # wasting CPU time and developer time. See
+        # https://github.com/bitcoin/bitcoin/issues/27380
+        #assert_equal(event.reason.decode("UTF-8"), "min relay fee not met")
+
+        bpf.cleanup()
+        self.generate(self.wallet, 1)
+
+    def run_test(self):
+        """Tests the mempool:added, mempool:removed, mempool:replaced,
+        and mempool:rejected tracepoints."""
+
+        # Create some coinbase transactions and mature them so they can be spent
+        node = self.nodes[0]
+        self.wallet = MiniWallet(node)
+        self.generate(self.wallet, 4)
+        self.generate(node, COINBASE_MATURITY)
+
+        # Test individual tracepoints
+        self.added_test()
+        self.removed_test()
+        self.replaced_test()
+        self.rejected_test()
+
+
+if __name__ == "__main__":
+    MempoolTracepointTest().main()
diff --git a/test/functional/interface_usdt_utxocache.py b/test/functional/interface_usdt_utxocache.py
index 55e5fda2c8..ed84c535f5 100755
--- a/test/functional/interface_usdt_utxocache.py
+++ b/test/functional/interface_usdt_utxocache.py
@@ -401,13 +401,6 @@ class UTXOCacheTracepointTest(BitcoinTestFramework):
         expected_flushes.append(
             {"mode": "NONE", "for_prune": True, "size_fn": lambda x: x == BLOCKS_TO_MINE})
 
-        self.log.info("test the utxocache:flush tracepoint API with pruning")
-        self.log.info("hook into the utxocache:flush tracepoint")
-        ctx = USDT(pid=self.nodes[0].process.pid)
-        ctx.enable_probe(probe="utxocache:flush",
-                         fn_name="trace_utxocache_flush")
-        bpf = BPF(text=utxocache_flushes_program, usdt_contexts=[ctx], debug=0, cflags=["-Wno-error=implicit-function-declaration"])
-        bpf["utxocache_flush"].open_perf_buffer(handle_utxocache_flush)
 
         self.log.info(f"prune blockchain to trigger a flush for pruning")
         self.nodes[0].pruneblockchain(415)