diff --git a/api/transport/network_types.h b/api/transport/network_types.h
index c922cb3..9001e74 100644
--- a/api/transport/network_types.h
+++ b/api/transport/network_types.h
@@ -214,7 +214,10 @@
 struct ProbeClusterConfig {
   Timestamp at_time = Timestamp::PlusInfinity();
   DataRate target_data_rate = DataRate::Zero();
+  // Duration of a probe.
   TimeDelta target_duration = TimeDelta::Zero();
+  // Delta time between sent bursts of packets during probe.
+  TimeDelta min_probe_delta = TimeDelta::Millis(2);
   int32_t target_probe_count = 0;
   int32_t id = 0;
 };
diff --git a/modules/congestion_controller/goog_cc/probe_controller.cc b/modules/congestion_controller/goog_cc/probe_controller.cc
index 1a20807..44cb0a7 100644
--- a/modules/congestion_controller/goog_cc/probe_controller.cc
+++ b/modules/congestion_controller/goog_cc/probe_controller.cc
@@ -89,8 +89,10 @@
       further_exponential_probe_scale("step_size", 2),
       further_probe_threshold("further_probe_threshold", 0.7),
       abort_further_probe_if_max_lower_than_current("abort_further", false),
-      repeated_initial_probing_duration("initial_probing_duration",
-                                        TimeDelta::Seconds(5)),
+      repeated_initial_probing_time_period("initial_probing",
+                                           TimeDelta::Seconds(5)),
+      initial_probe_duration("initial_probe_duration", TimeDelta::Millis(100)),
+      initial_min_probe_delta("initial_min_probe_delta", TimeDelta::Millis(20)),
       alr_probing_interval("alr_interval", TimeDelta::Seconds(5)),
       alr_probe_scale("alr_scale", 2),
       network_state_estimate_probing_interval("network_state_interval",
@@ -104,13 +106,13 @@
       network_state_probe_scale("network_state_scale", 1.0),
       network_state_probe_duration("network_state_probe_duration",
                                    TimeDelta::Millis(15)),
-
       probe_on_max_allocated_bitrate_change("probe_max_allocation", true),
       first_allocation_probe_scale("alloc_p1", 1),
       second_allocation_probe_scale("alloc_p2", 2),
       allocation_probe_limit_by_current_scale("alloc_current_bwe_limit"),
       min_probe_packets_sent("min_probe_packets_sent", 5),
       min_probe_duration("min_probe_duration", TimeDelta::Millis(15)),
+      min_probe_delta("min_probe_delta", TimeDelta::Millis(2)),
       loss_limited_probe_scale("loss_limited_scale", 1.5),
       skip_if_estimate_larger_than_fraction_of_max(
           "skip_if_est_larger_than_fraction_of_max",
@@ -120,7 +122,8 @@
                    &further_exponential_probe_scale,
                    &further_probe_threshold,
                    &abort_further_probe_if_max_lower_than_current,
-                   &repeated_initial_probing_duration,
+                   &repeated_initial_probing_time_period,
+                   &initial_probe_duration,
                    &alr_probing_interval,
                    &alr_probe_scale,
                    &probe_on_max_allocated_bitrate_change,
@@ -128,6 +131,8 @@
                    &second_allocation_probe_scale,
                    &allocation_probe_limit_by_current_scale,
                    &min_probe_duration,
+                   &min_probe_delta,
+                   &initial_min_probe_delta,
                    &network_state_estimate_probing_interval,
                    &probe_if_estimate_lower_than_network_state_estimate_ratio,
                    &estimate_lower_than_network_state_estimate_probing_interval,
@@ -217,7 +222,6 @@
     Timestamp at_time) {
   const bool in_alr = alr_start_time_.has_value();
   const bool allow_allocation_probe = in_alr;
-
   if (config_.probe_on_max_allocated_bitrate_change &&
       state_ == State::kProbingComplete &&
       max_total_allocated_bitrate != max_total_allocated_bitrate_ &&
@@ -257,6 +261,10 @@
 
     return InitiateProbing(at_time, probes, allow_further_probing);
   }
+  if (!max_total_allocated_bitrate.IsZero()) {
+    last_allowed_repeated_initial_probe_ = at_time;
+  }
+
   max_total_allocated_bitrate_ = max_total_allocated_bitrate;
   return std::vector<ProbeClusterConfig>();
 }
@@ -285,7 +293,6 @@
       break;
     case State::kProbingComplete:
       state_ = State::kProbingComplete;
-      waiting_for_initial_probe_result_ = false;
       min_bitrate_to_probe_further_ = DataRate::PlusInfinity();
       break;
   }
@@ -306,13 +313,13 @@
     probes.push_back(config_.second_exponential_probe_scale.Value() *
                      start_bitrate_);
   }
-  waiting_for_initial_probe_result_ = true;
-  if (repeated_initial_probing_enabled_) {
+  if (repeated_initial_probing_enabled_ &&
+      max_total_allocated_bitrate_.IsZero()) {
     last_allowed_repeated_initial_probe_ =
-        at_time + config_.repeated_initial_probing_duration;
+        at_time + config_.repeated_initial_probing_time_period;
     RTC_LOG(LS_INFO) << "Repeated initial probing enabled, last allowed probe: "
                      << last_allowed_repeated_initial_probe_
-                     << "now: " << at_time;
+                     << " now: " << at_time;
   }
 
   return InitiateProbing(at_time, probes, true);
@@ -335,8 +342,6 @@
     if (config_.abort_further_probe_if_max_lower_than_current &&
         (bitrate > max_bitrate_ ||
          (!max_total_allocated_bitrate_.IsZero() &&
-          !(waiting_for_initial_probe_result_ &&
-            repeated_initial_probing_enabled_) &&
           bitrate > 2 * max_total_allocated_bitrate_))) {
       // No need to continue probing.
       min_bitrate_to_probe_further_ = DataRate::PlusInfinity();
@@ -425,7 +430,6 @@
 void ProbeController::Reset(Timestamp at_time) {
   bandwidth_limited_cause_ = BandwidthLimitedCause::kDelayBasedLimited;
   state_ = State::kInit;
-  waiting_for_initial_probe_result_ = false;
   min_bitrate_to_probe_further_ = DataRate::PlusInfinity();
   time_last_probing_initiated_ = Timestamp::Zero();
   estimated_bitrate_ = DataRate::Zero();
@@ -437,7 +441,6 @@
   alr_end_time_.reset();
   time_of_last_large_drop_ = now;
   bitrate_before_last_large_drop_ = DataRate::Zero();
-  max_total_allocated_bitrate_ = DataRate::Zero();
 }
 
 bool ProbeController::TimeForAlrProbe(Timestamp at_time) const {
@@ -506,7 +509,6 @@
     return {};
   }
   if (TimeForNextRepeatedInitialProbe(at_time)) {
-    waiting_for_initial_probe_result_ = true;
     return InitiateProbing(
         at_time, {estimated_bitrate_ * config_.first_exponential_probe_scale},
         true);
@@ -518,6 +520,29 @@
   return std::vector<ProbeClusterConfig>();
 }
 
+ProbeClusterConfig ProbeController::CreateProbeClusterConfig(Timestamp at_time,
+                                                             DataRate bitrate) {
+  ProbeClusterConfig config;
+  config.at_time = at_time;
+  config.target_data_rate = bitrate;
+  if (network_estimate_ &&
+      config_.network_state_estimate_probing_interval->IsFinite()) {
+    config.target_duration = config_.network_state_probe_duration;
+    config.min_probe_delta = config_.min_probe_delta;
+  } else if (at_time < last_allowed_repeated_initial_probe_) {
+    config.target_duration = config_.initial_probe_duration;
+    config.min_probe_delta = config_.initial_min_probe_delta;
+  } else {
+    config.target_duration = config_.min_probe_duration;
+    config.min_probe_delta = config_.min_probe_delta;
+  }
+  config.target_probe_count = config_.min_probe_packets_sent;
+  config.id = next_probe_cluster_id_;
+  next_probe_cluster_id_++;
+  MaybeLogProbeClusterCreated(event_log_, config);
+  return config;
+}
+
 std::vector<ProbeClusterConfig> ProbeController::InitiateProbing(
     Timestamp now,
     std::vector<DataRate> bitrates_to_probe,
@@ -538,9 +563,7 @@
   }
 
   DataRate max_probe_bitrate = max_bitrate_;
-  if (max_total_allocated_bitrate_ > DataRate::Zero() &&
-      !(repeated_initial_probing_enabled_ &&
-        waiting_for_initial_probe_result_)) {
+  if (max_total_allocated_bitrate_ > DataRate::Zero()) {
     // If a max allocated bitrate has been configured, allow probing up to 2x
     // that rate. This allows some overhead to account for bursty streams,
     // which otherwise would have to ramp up when the overshoot is already in
@@ -556,7 +579,8 @@
     case BandwidthLimitedCause::kRttBasedBackOffHighRtt:
     case BandwidthLimitedCause::kDelayBasedLimitedDelayIncreased:
     case BandwidthLimitedCause::kLossLimitedBwe:
-      RTC_LOG(LS_INFO) << "Not sending probe in bandwidth limited state.";
+      RTC_LOG(LS_INFO) << "Not sending probe in bandwidth limited state. "
+                       << static_cast<int>(bandwidth_limited_cause_);
       return {};
     case BandwidthLimitedCause::kLossLimitedBweIncreasing:
       estimate_capped_bitrate =
@@ -590,21 +614,7 @@
       probe_further = false;
     }
 
-    ProbeClusterConfig config;
-    config.at_time = now;
-    config.target_data_rate = bitrate;
-    if (network_estimate_ &&
-        config_.network_state_estimate_probing_interval->IsFinite()) {
-      config.target_duration = config_.network_state_probe_duration;
-    } else {
-      config.target_duration = config_.min_probe_duration;
-    }
-
-    config.target_probe_count = config_.min_probe_packets_sent;
-    config.id = next_probe_cluster_id_;
-    next_probe_cluster_id_++;
-    MaybeLogProbeClusterCreated(event_log_, config);
-    pending_probes.push_back(config);
+    pending_probes.push_back(CreateProbeClusterConfig(now, bitrate));
   }
   time_last_probing_initiated_ = now;
   if (probe_further) {
diff --git a/modules/congestion_controller/goog_cc/probe_controller.h b/modules/congestion_controller/goog_cc/probe_controller.h
index 4a13d17..96c6091 100644
--- a/modules/congestion_controller/goog_cc/probe_controller.h
+++ b/modules/congestion_controller/goog_cc/probe_controller.h
@@ -45,12 +45,16 @@
   FieldTrialParameter<bool> abort_further_probe_if_max_lower_than_current;
   // Duration of time from the first initial probe where repeated initial probes
   // are sent if repeated initial probing is enabled.
-  FieldTrialParameter<TimeDelta> repeated_initial_probing_duration;
-
+  FieldTrialParameter<TimeDelta> repeated_initial_probing_time_period;
+  // The minimum probing duration of an individual probe during
+  // the repeated_initial_probing_time_period.
+  FieldTrialParameter<TimeDelta> initial_probe_duration;
+  // Delta time between sent bursts of packets in a probe during
+  // the repeated_initial_probing_time_period.
+  FieldTrialParameter<TimeDelta> initial_min_probe_delta;
   // Configures how often we send ALR probes and how big they are.
   FieldTrialParameter<TimeDelta> alr_probing_interval;
   FieldTrialParameter<double> alr_probe_scale;
-
   // Configures how often we send probes if NetworkStateEstimate is available.
   FieldTrialParameter<TimeDelta> network_state_estimate_probing_interval;
   // Periodically probe as long as the ratio between current estimate and
@@ -74,6 +78,8 @@
   FieldTrialParameter<int> min_probe_packets_sent;
   // The minimum probing duration.
   FieldTrialParameter<TimeDelta> min_probe_duration;
+  // Delta time between sent bursts of packets in a probe.
+  FieldTrialParameter<TimeDelta> min_probe_delta;
   FieldTrialParameter<double> loss_limited_probe_scale;
   // Don't send a probe if min(estimate, network state estimate) is larger than
   // this fraction of the set max bitrate.
@@ -83,7 +89,7 @@
 // Reason that bandwidth estimate is limited. Bandwidth estimate can be limited
 // by either delay based bwe, or loss based bwe when it increases/decreases the
 // estimate.
-enum class BandwidthLimitedCause {
+enum class BandwidthLimitedCause : int {
   kLossLimitedBweIncreasing = 0,
   kLossLimitedBwe = 1,
   kDelayBasedLimited = 2,
@@ -126,8 +132,10 @@
   void EnablePeriodicAlrProbing(bool enable);
 
   // Probes are sent periodically every 1s during the first 5s after the network
-  // becomes available. The probes ignores allocated bitrate constraints and
-  // probe up to max configured bitrate configured via SetBitrates.
+  // becomes available or until OnMaxTotalAllocatedBitrate is invoked with a
+  // none zero max_total_allocated_bitrate (there are active streams being
+  // sent.) Probe rate is up to max configured bitrate configured via
+  // SetBitrates.
   void EnableRepeatedInitialProbing(bool enable);
 
   void SetAlrStartTimeMs(absl::optional<int64_t> alr_start_time);
@@ -139,8 +147,9 @@
   void SetNetworkStateEstimate(webrtc::NetworkStateEstimate estimate);
 
   // Resets the ProbeController to a state equivalent to as if it was just
-  // created EXCEPT for `enable_periodic_alr_probing_` and
-  // `network_available_`.
+  // created EXCEPT for configuration settings like
+  // `enable_periodic_alr_probing_` `network_available_` and
+  // `max_total_allocated_bitrate_`.
   void Reset(Timestamp at_time);
 
   ABSL_MUST_USE_RESULT std::vector<ProbeClusterConfig> Process(
@@ -166,9 +175,10 @@
   bool TimeForAlrProbe(Timestamp at_time) const;
   bool TimeForNetworkStateProbe(Timestamp at_time) const;
   bool TimeForNextRepeatedInitialProbe(Timestamp at_time) const;
+  ProbeClusterConfig CreateProbeClusterConfig(Timestamp at_time,
+                                              DataRate bitrate);
 
   bool network_available_;
-  bool waiting_for_initial_probe_result_ = false;
   bool repeated_initial_probing_enabled_ = false;
   Timestamp last_allowed_repeated_initial_probe_ = Timestamp::MinusInfinity();
   BandwidthLimitedCause bandwidth_limited_cause_ =
diff --git a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
index 4821485..e75c2c8 100644
--- a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
+++ b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
@@ -378,37 +378,6 @@
   EXPECT_THAT(probes, IsEmpty());
 }
 
-TEST(ProbeControllerTest, RepeatedInitialProbingIgnoreLowMaxAllocatedbitrate) {
-  ProbeControllerFixture fixture;
-  std::unique_ptr<ProbeController> probe_controller =
-      fixture.CreateController();
-  ASSERT_THAT(
-      probe_controller->OnNetworkAvailability({.network_available = true}),
-      IsEmpty());
-  auto probes = probe_controller->SetBitrates(
-      kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
-  ASSERT_THAT(probes, SizeIs(Gt(0)));
-  probe_controller->EnableRepeatedInitialProbing(true);
-
-  // Repeated probe is sent when estimated bitrate climbs above
-  // 0.7 * 6 * kStartBitrate = 1260. During the initial probe, we ignore the
-  // allocation limit and probe up to the max.
-  probes = probe_controller->OnMaxTotalAllocatedBitrate(kStartBitrate,
-                                                        fixture.CurrentTime());
-  EXPECT_THAT(probes, IsEmpty());
-
-  probes = probe_controller->SetEstimatedBitrate(
-      DataRate::BitsPerSec(1800), BandwidthLimitedCause::kDelayBasedLimited,
-      fixture.CurrentTime());
-  EXPECT_EQ(probes.size(), 1u);
-  EXPECT_EQ(probes[0].target_data_rate.bps(), 2 * 1800);
-
-  probes = probe_controller->SetEstimatedBitrate(
-      probes[0].target_data_rate, BandwidthLimitedCause::kDelayBasedLimited,
-      fixture.CurrentTime());
-  EXPECT_EQ(probes.size(), 1u);
-}
-
 TEST(ProbeControllerTest, InitialProbingToLowMaxAllocatedbitrate) {
   ProbeControllerFixture fixture;
   std::unique_ptr<ProbeController> probe_controller =
@@ -475,6 +444,8 @@
       // Expect a probe every second.
       EXPECT_EQ(fixture.CurrentTime() - last_probe_time,
                 TimeDelta::Seconds(1.1));
+      EXPECT_EQ(probes[0].min_probe_delta, TimeDelta::Millis(20));
+      EXPECT_EQ(probes[0].target_duration, TimeDelta::Millis(100));
       last_probe_time = fixture.CurrentTime();
     } else {
       EXPECT_LT(fixture.CurrentTime() - last_probe_time,
@@ -486,6 +457,28 @@
   EXPECT_THAT(probe_controller->Process(fixture.CurrentTime()), IsEmpty());
 }
 
+TEST(ProbeControllerTest, RepeatedInitialProbingStopIfMaxAllocatedBitrateSet) {
+  ProbeControllerFixture fixture;
+  std::unique_ptr<ProbeController> probe_controller =
+      fixture.CreateController();
+  probe_controller->EnableRepeatedInitialProbing(true);
+  ASSERT_THAT(
+      probe_controller->OnNetworkAvailability({.network_available = true}),
+      IsEmpty());
+  auto probes = probe_controller->SetBitrates(
+      kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
+  EXPECT_THAT(probes, SizeIs(Gt(0)));
+
+  fixture.AdvanceTime(TimeDelta::Millis(1100));
+  probes = probe_controller->Process(fixture.CurrentTime());
+  EXPECT_THAT(probes, SizeIs(1));
+  probes = probe_controller->OnMaxTotalAllocatedBitrate(kMinBitrate,
+                                                        fixture.CurrentTime());
+  fixture.AdvanceTime(TimeDelta::Millis(1100));
+  probes = probe_controller->Process(fixture.CurrentTime());
+  EXPECT_THAT(probes, IsEmpty());
+}
+
 TEST(ProbeControllerTest, RequestProbeInAlr) {
   ProbeControllerFixture fixture;
   std::unique_ptr<ProbeController> probe_controller =
@@ -1274,6 +1267,27 @@
   EXPECT_TRUE(probes.empty());
 }
 
+TEST(ProbeControllerTest, MaxAllocatedBitrateNotReset) {
+  ProbeControllerFixture fixture;
+  std::unique_ptr<ProbeController> probe_controller =
+      fixture.CreateController();
+  ASSERT_THAT(
+      probe_controller->OnNetworkAvailability({.network_available = true}),
+      IsEmpty());
+  auto probes = probe_controller->SetBitrates(
+      kMinBitrate, kStartBitrate, kMaxBitrate, fixture.CurrentTime());
+  ASSERT_FALSE(probes.empty());
+
+  probes = probe_controller->OnMaxTotalAllocatedBitrate(kStartBitrate / 4,
+                                                        fixture.CurrentTime());
+  probe_controller->Reset(fixture.CurrentTime());
+
+  probes = probe_controller->SetBitrates(kMinBitrate, kStartBitrate,
+                                         kMaxBitrate, fixture.CurrentTime());
+  ASSERT_FALSE(probes.empty());
+  EXPECT_EQ(probes[0].target_data_rate, kStartBitrate / 4 * 2);
+}
+
 TEST(ProbeControllerTest, SkipAlrProbeIfEstimateLargerThanMaxProbe) {
   ProbeControllerFixture fixture(
       "WebRTC-Bwe-ProbingConfiguration/"
diff --git a/modules/pacing/BUILD.gn b/modules/pacing/BUILD.gn
index a24bccd..e8e19b1 100644
--- a/modules/pacing/BUILD.gn
+++ b/modules/pacing/BUILD.gn
@@ -98,6 +98,7 @@
       ":interval_budget",
       ":pacing",
       "../../api/task_queue:task_queue",
+      "../../api/transport:field_trial_based_config",
       "../../api/transport:network_control",
       "../../api/units:data_rate",
       "../../api/units:data_size",
diff --git a/modules/pacing/bitrate_prober.cc b/modules/pacing/bitrate_prober.cc
index 17729b5..29b4f4c 100644
--- a/modules/pacing/bitrate_prober.cc
+++ b/modules/pacing/bitrate_prober.cc
@@ -12,7 +12,9 @@
 
 #include <algorithm>
 
+#include "api/field_trials_view.h"
 #include "api/units/data_size.h"
+#include "api/units/time_delta.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 
@@ -26,10 +28,9 @@
 
 BitrateProberConfig::BitrateProberConfig(
     const FieldTrialsView* key_value_config)
-    : min_probe_delta("min_probe_delta", TimeDelta::Millis(2)),
-      max_probe_delay("max_probe_delay", TimeDelta::Millis(10)),
+    : max_probe_delay("max_probe_delay", TimeDelta::Millis(10)),
       min_packet_size("min_packet_size", DataSize::Bytes(200)) {
-  ParseFieldTrial({&min_probe_delta, &max_probe_delay, &min_packet_size},
+  ParseFieldTrial({&max_probe_delay, &min_packet_size},
                   key_value_config->Lookup("WebRTC-Bwe-ProbingBehavior"));
 }
 
@@ -93,6 +94,7 @@
 void BitrateProber::CreateProbeCluster(
     const ProbeClusterConfig& cluster_config) {
   RTC_DCHECK(probing_state_ != ProbingState::kDisabled);
+  RTC_DCHECK(cluster_config.min_probe_delta > TimeDelta::Zero());
 
   while (!clusters_.empty() &&
          (cluster_config.at_time - clusters_.front().requested_at >
@@ -109,6 +111,7 @@
       (cluster_config.target_data_rate * cluster_config.target_duration)
           .bytes();
   RTC_DCHECK_GE(cluster.pace_info.probe_cluster_min_bytes, 0);
+  cluster.min_probe_delta = cluster_config.min_probe_delta;
   cluster.pace_info.send_bitrate = cluster_config.target_data_rate;
   cluster.pace_info.probe_cluster_id = cluster_config.id;
   clusters_.push(cluster);
@@ -164,7 +167,7 @@
     return DataSize::Zero();
   }
   DataRate send_rate = clusters_.front().pace_info.send_bitrate;
-  return send_rate * config_.min_probe_delta;
+  return send_rate * clusters_.front().min_probe_delta;
 }
 
 void BitrateProber::ProbeSent(Timestamp now, DataSize size) {
diff --git a/modules/pacing/bitrate_prober.h b/modules/pacing/bitrate_prober.h
index 821bbf3..149d24f 100644
--- a/modules/pacing/bitrate_prober.h
+++ b/modules/pacing/bitrate_prober.h
@@ -16,8 +16,10 @@
 
 #include <queue>
 
-#include "api/transport/field_trial_based_config.h"
+#include "api/field_trials_view.h"
 #include "api/transport/network_types.h"
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
 #include "rtc_base/experiments/field_trial_parser.h"
 
 namespace webrtc {
@@ -29,8 +31,6 @@
   BitrateProberConfig& operator=(const BitrateProberConfig&) = default;
   ~BitrateProberConfig() = default;
 
-  // A minimum interval between probes to allow scheduling to be feasible.
-  FieldTrialParameter<TimeDelta> min_probe_delta;
   // Maximum amount of time each probe can be delayed.
   FieldTrialParameter<TimeDelta> max_probe_delay;
   // This is used to start sending a probe after a large enough packet.
@@ -103,9 +103,9 @@
 
     int sent_probes = 0;
     int sent_bytes = 0;
+    TimeDelta min_probe_delta = TimeDelta::Zero();
     Timestamp requested_at = Timestamp::MinusInfinity();
     Timestamp started_at = Timestamp::MinusInfinity();
-    int retries = 0;
   };
 
   Timestamp CalculateNextProbeTime(const ProbeCluster& cluster) const;
diff --git a/modules/pacing/bitrate_prober_unittest.cc b/modules/pacing/bitrate_prober_unittest.cc
index 3c1c93f..2954398 100644
--- a/modules/pacing/bitrate_prober_unittest.cc
+++ b/modules/pacing/bitrate_prober_unittest.cc
@@ -12,6 +12,7 @@
 
 #include <algorithm>
 
+#include "api/transport/field_trial_based_config.h"
 #include "api/transport/network_types.h"
 #include "api/units/data_rate.h"
 #include "api/units/time_delta.h"
@@ -39,11 +40,13 @@
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = kTestBitrate1,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = kTestBitrate2,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 1});
   EXPECT_FALSE(prober.is_probing());
@@ -100,6 +103,7 @@
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = DataRate::KilobitsPerSec(900),
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   EXPECT_FALSE(prober.is_probing());
@@ -125,6 +129,7 @@
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = DataRate::KilobitsPerSec(900),
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
 
@@ -154,6 +159,7 @@
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = DataRate::KilobitsPerSec(900),
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   prober.OnIncomingPacket(kProbeSize);
@@ -165,6 +171,7 @@
         {.at_time = now,
          .target_data_rate = DataRate::KilobitsPerSec(900),
          .target_duration = TimeDelta::Millis(15),
+         .min_probe_delta = TimeDelta::Millis(2),
          .target_probe_count = 5,
          .id = i});
     prober.OnIncomingPacket(kProbeSize);
@@ -190,6 +197,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = DataRate::KilobitsPerSec(1000),
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   prober.OnIncomingPacket(DataSize::Bytes(100));
@@ -208,6 +216,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = DataRate::KilobitsPerSec(1000),
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   prober.OnIncomingPacket(DataSize::Bytes(10));
@@ -224,6 +233,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = kHighBitrate,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   // Probe size should ensure a minimum of 1 ms interval.
@@ -231,10 +241,9 @@
             kHighBitrate * TimeDelta::Millis(1));
 }
 
-TEST(BitrateProberTest, ProbeSizeCanBeSetWithFieldTrial) {
-  const test::ExplicitKeyValueConfig trials(
-      "WebRTC-Bwe-ProbingBehavior/min_probe_delta:20ms/");
-  BitrateProber prober(trials);
+TEST(BitrateProberTest, ProbeSizeCanBeSetInProbeClusterConfig) {
+  const FieldTrialBasedConfig config;
+  BitrateProber prober(config);
   prober.SetEnabled(true);
 
   const DataRate kHighBitrate = DataRate::KilobitsPerSec(10000);  // 10 Mbps
@@ -242,6 +251,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = kHighBitrate,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(20),
                              .target_probe_count = 5,
                              .id = 0});
   EXPECT_EQ(prober.RecommendedMinProbeSize(),
@@ -267,6 +277,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = kBitrate,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
 
@@ -290,6 +301,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = kBitrate,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   prober.OnIncomingPacket(kPacketSize);
@@ -314,6 +326,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = kBitrate,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   prober.OnIncomingPacket(kPacketSize);
@@ -340,6 +353,7 @@
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = kBitrate,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   prober.OnIncomingPacket(kSmallPacketSize);
@@ -348,6 +362,7 @@
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = kBitrate / 10,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 1});
   prober.OnIncomingPacket(kSmallPacketSize);
@@ -356,6 +371,7 @@
   prober.CreateProbeCluster({.at_time = now,
                              .target_data_rate = kBitrate / 10,
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 2});
   prober.OnIncomingPacket(kSmallPacketSize);
@@ -378,6 +394,7 @@
   prober.CreateProbeCluster({.at_time = Timestamp::Zero(),
                              .target_data_rate = DataRate::KilobitsPerSec(300),
                              .target_duration = TimeDelta::Millis(15),
+                             .min_probe_delta = TimeDelta::Millis(2),
                              .target_probe_count = 5,
                              .id = 0});
   EXPECT_TRUE(prober.is_probing());
@@ -392,6 +409,7 @@
       .at_time = Timestamp::Zero(),
       .target_data_rate = DataRate::KilobitsPerSec(300),
       .target_duration = TimeDelta::Millis(15),
+      .min_probe_delta = TimeDelta::Millis(2),
       .target_probe_count = 1,
       .id = 0};
   prober.CreateProbeCluster(cluster_config);
diff --git a/modules/pacing/task_queue_paced_sender_unittest.cc b/modules/pacing/task_queue_paced_sender_unittest.cc
index f0a9ad7..fda6615 100644
--- a/modules/pacing/task_queue_paced_sender_unittest.cc
+++ b/modules/pacing/task_queue_paced_sender_unittest.cc
@@ -443,8 +443,7 @@
 TEST(TaskQueuePacedSenderTest, NoMinSleepTimeWhenProbing) {
   // Set min_probe_delta to be less than kMinSleepTime (1ms).
   const TimeDelta kMinProbeDelta = TimeDelta::Micros(200);
-  ScopedKeyValueConfig trials(
-      "WebRTC-Bwe-ProbingBehavior/min_probe_delta:200us/");
+  ScopedKeyValueConfig trials;
   GlobalSimulatedTimeController time_controller(Timestamp::Millis(1234));
   MockPacketRouter packet_router;
   TaskQueuePacedSender pacer(time_controller.GetClock(), &packet_router, trials,
@@ -473,6 +472,7 @@
       {{.at_time = time_controller.GetClock()->CurrentTime(),
         .target_data_rate = kProbingRate,
         .target_duration = TimeDelta::Millis(15),
+        .min_probe_delta = kMinProbeDelta,
         .target_probe_count = 5,
         .id = kProbeClusterId}});
 
diff --git a/test/peer_scenario/tests/bwe_ramp_up_test.cc b/test/peer_scenario/tests/bwe_ramp_up_test.cc
index f8eaa47..909d989 100644
--- a/test/peer_scenario/tests/bwe_ramp_up_test.cc
+++ b/test/peer_scenario/tests/bwe_ramp_up_test.cc
@@ -199,7 +199,7 @@
 
   // Test that 1s after offer/answer exchange finish, we have a BWE estimate,
   // even though no video frames have been sent.
-  s.ProcessMessages(TimeDelta::Seconds(1));
+  s.ProcessMessages(TimeDelta::Seconds(2));
 
   auto callee_inbound_stats =
       GetStatsAndProcess(s, callee)->GetStatsOfType<RTCInboundRtpStreamStats>();