diff --git a/src/net.h b/src/net.h
--- a/src/net.h
+++ b/src/net.h
@@ -297,6 +297,13 @@
 
     void WakeMessageHandler();
 
+    /**
+     * Attempts to obfuscate tx time through exponentially distributed emitting.
+     * Works assuming that a single interval is used.
+     * Variable intervals will result in privacy decrease.
+     */
+    int64_t PoissonNextSendInbound(int64_t now, int average_interval_seconds);
+
 private:
     struct ListenSocket {
         SOCKET socket;
@@ -424,6 +431,8 @@
      */
     std::atomic_bool m_try_another_outbound_peer;
 
+    std::atomic<int64_t> m_next_send_inv_to_incoming;
+
     friend struct CConnmanTest;
 };
 
@@ -842,7 +851,7 @@
  * Return a timestamp in the future (in microseconds) for exponentially
  * distributed events.
  */
-int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds);
+int64_t PoissonNextSend(int64_t now, int average_interval_seconds);
 
 std::string getSubVersionEB(uint64_t MaxBlockSize);
 std::string userAgent(const Config &config);
diff --git a/src/net.cpp b/src/net.cpp
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -2741,11 +2741,24 @@
     return found != nullptr && NodeFullyConnected(found) && func(found);
 }
 
-int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds) {
-    return nNow + int64_t(log1p(GetRand(1ULL << 48) *
-                                -0.0000000000000035527136788 /* -1/2^48 */) *
-                              average_interval_seconds * -1000000.0 +
-                          0.5);
+int64_t CConnman::PoissonNextSendInbound(int64_t now,
+                                         int average_interval_seconds) {
+    if (m_next_send_inv_to_incoming < now) {
+        // If this function were called from multiple threads simultaneously
+        // it would be possible that both update the next send variable, and
+        // return a different result to their caller. This is not possible in
+        // practice as only the net processing thread invokes this function.
+        m_next_send_inv_to_incoming =
+            PoissonNextSend(now, average_interval_seconds);
+    }
+    return m_next_send_inv_to_incoming;
+}
+
+int64_t PoissonNextSend(int64_t now, int average_interval_seconds) {
+    return now + int64_t(log1p(GetRand(1ULL << 48) *
+                               -0.0000000000000035527136788 /* -1/2^48 */) *
+                             average_interval_seconds * -1000000.0 +
+                         0.5);
 }
 
 CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const {
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -132,6 +132,36 @@
 
 void EraseOrphansFor(NodeId peer);
 
+/**
+ * Average delay between local address broadcasts in seconds.
+ */
+static constexpr unsigned int AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL =
+    24 * 60 * 60;
+/**
+ * Average delay between peer address broadcasts in seconds.
+ */
+static const unsigned int AVG_ADDRESS_BROADCAST_INTERVAL = 30;
+/**
+ * Average delay between trickled inventory transmissions in seconds.
+ * Blocks and whitelisted receivers bypass this, outbound peers get half this
+ * delay.
+ */
+static const unsigned int INVENTORY_BROADCAST_INTERVAL = 5;
+/**
+ * Maximum number of inventory items to send per transmission.
+ * Limits the impact of low-fee transaction floods.
+ */
+static constexpr unsigned int INVENTORY_BROADCAST_MAX_PER_MB =
+    7 * INVENTORY_BROADCAST_INTERVAL;
+/**
+ * Average delay between feefilter broadcasts in seconds.
+ */
+static constexpr unsigned int AVG_FEEFILTER_BROADCAST_INTERVAL = 10 * 60;
+/**
+ * Maximum feefilter broadcast delay after significant change.
+ */
+static constexpr unsigned int MAX_FEEFILTER_CHANGE_DELAY = 5 * 60;
+
 // Internal stuff
 namespace {
 /** Number of nodes with fSyncStarted. */
@@ -4356,10 +4386,15 @@
         bool fSendTrickle = pto->fWhitelisted;
         if (pto->nNextInvSend < nNow) {
             fSendTrickle = true;
-            // Use half the delay for outbound peers, as there is less privacy
-            // concern for them.
-            pto->nNextInvSend = PoissonNextSend(
-                nNow, INVENTORY_BROADCAST_INTERVAL >> !pto->fInbound);
+            if (pto->fInbound) {
+                pto->nNextInvSend = connman->PoissonNextSendInbound(
+                    nNow, INVENTORY_BROADCAST_INTERVAL);
+            } else {
+                // Use half the delay for outbound peers, as there is less
+                // privacy concern for them.
+                pto->nNextInvSend =
+                    PoissonNextSend(nNow, INVENTORY_BROADCAST_INTERVAL >> 1);
+            }
         }
 
         // Time to send but the peer has requested we not relay transactions.
diff --git a/src/validation.h b/src/validation.h
--- a/src/validation.h
+++ b/src/validation.h
@@ -138,26 +138,6 @@
 static const unsigned int DATABASE_FLUSH_INTERVAL = 24 * 60 * 60;
 /** Maximum length of reject messages. */
 static const unsigned int MAX_REJECT_MESSAGE_LENGTH = 111;
-/** Average delay between local address broadcasts in seconds. */
-static const unsigned int AVG_LOCAL_ADDRESS_BROADCAST_INTERVAL = 24 * 60 * 60;
-/** Average delay between peer address broadcasts in seconds. */
-static const unsigned int AVG_ADDRESS_BROADCAST_INTERVAL = 30;
-/**
- * Average delay between trickled inventory transmissions in seconds.
- * Blocks and whitelisted receivers bypass this, outbound peers get half this
- * delay.
- */
-static const unsigned int INVENTORY_BROADCAST_INTERVAL = 5;
-/**
- * Maximum number of inventory items to send per transmission.
- * Limits the impact of low-fee transaction floods.
- */
-static const unsigned int INVENTORY_BROADCAST_MAX_PER_MB =
-    7 * INVENTORY_BROADCAST_INTERVAL;
-/** Average delay between feefilter broadcasts in seconds. */
-static const unsigned int AVG_FEEFILTER_BROADCAST_INTERVAL = 10 * 60;
-/** Maximum feefilter broadcast delay after significant change. */
-static const unsigned int MAX_FEEFILTER_CHANGE_DELAY = 5 * 60;
 /** Block download timeout base, expressed in millionths of the block interval
  * (i.e. 10 min) */
 static const int64_t BLOCK_DOWNLOAD_TIMEOUT_BASE = 1000000;