diff --git a/modules/congestion_controller/delay_based_bwe_unittest.cc b/modules/congestion_controller/delay_based_bwe_unittest.cc
index 311e8e8266..765504459f 100644
--- a/modules/congestion_controller/delay_based_bwe_unittest.cc
+++ b/modules/congestion_controller/delay_based_bwe_unittest.cc
@@ -139,6 +139,15 @@ TEST_F(DelayBasedBweTest, ProbeDetectionSlowerArrivalHighBitrate) {
               kTargetUtilizationFraction * 4000000u, 10000u);
 }
 
+TEST_F(DelayBasedBweTest, GetExpectedBwePeriodMs) {
+  int64_t default_interval_ms = bitrate_estimator_->GetExpectedBwePeriodMs();
+  EXPECT_GT(default_interval_ms, 0);
+  CapacityDropTestHelper(1, true, 333, 0);
+  int64_t interval_ms = bitrate_estimator_->GetExpectedBwePeriodMs();
+  EXPECT_GT(interval_ms, 0);
+  EXPECT_NE(interval_ms, default_interval_ms);
+}
+
 TEST_F(DelayBasedBweTest, InitialBehavior) {
   InitialBehaviorTestHelper(730000);
 }
diff --git a/modules/remote_bitrate_estimator/aimd_rate_control.cc b/modules/remote_bitrate_estimator/aimd_rate_control.cc
index d91f2cb342..2daac01d21 100644
--- a/modules/remote_bitrate_estimator/aimd_rate_control.cc
+++ b/modules/remote_bitrate_estimator/aimd_rate_control.cc
@@ -136,12 +136,13 @@ int AimdRateControl::GetNearMaxIncreaseRateBps() const {
 }
 
 int AimdRateControl::GetExpectedBandwidthPeriodMs() const {
-  constexpr int kMinPeriodMs = 500;
+  constexpr int kMinPeriodMs = 2000;
+  constexpr int kDefaultPeriodMs = 3000;
   constexpr int kMaxPeriodMs = 50000;
 
   int increase_rate = GetNearMaxIncreaseRateBps();
   if (!last_decrease_)
-    return kMinPeriodMs;
+    return kDefaultPeriodMs;
 
   return std::min(kMaxPeriodMs,
                   std::max<int>(1000 * static_cast<int64_t>(*last_decrease_) /
@@ -210,17 +211,8 @@ uint32_t AimdRateControl::ChangeBitrate(uint32_t new_bitrate_bps,
 
       if (bitrate_is_initialized_ &&
           incoming_bitrate_bps < current_bitrate_bps_) {
-        constexpr float kDegradationFactor = 0.9f;
-        if (new_bitrate_bps <
-            kDegradationFactor * beta_ * current_bitrate_bps_) {
-          // If bitrate decreases more than a normal back off after overuse, it
-          // indicates a real network degradation. We do not let such a decrease
-          // to determine the bandwidth estimation period.
-          last_decrease_ = rtc::Optional<int>();
-        } else {
-          last_decrease_ = rtc::Optional<int>(
-              current_bitrate_bps_ - new_bitrate_bps);
-        }
+        last_decrease_ =
+            rtc::Optional<int>(current_bitrate_bps_ - new_bitrate_bps);
       }
       if (incoming_bitrate_kbps <
           avg_max_bitrate_kbps_ - 3 * std_max_bit_rate) {
diff --git a/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc b/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc
index a7bb752ee6..690eb688f0 100644
--- a/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc
+++ b/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc
@@ -18,8 +18,9 @@ namespace {
 
 constexpr int64_t kClockInitialTime = 123456;
 
-constexpr int kMinBwePeriodMs = 500;
+constexpr int kMinBwePeriodMs = 2000;
 constexpr int kMaxBwePeriodMs = 50000;
+constexpr int kDefaultPeriodMs = 3000;
 
 // After an overuse, we back off to 85% to the received bitrate.
 constexpr double kFractionAfterOveruse = 0.85;
@@ -81,8 +82,7 @@ TEST(AimdRateControlTest, GetIncreaseRateAndBandwidthPeriod) {
                     states.simulated_clock->TimeInMilliseconds());
   EXPECT_NEAR(14000, states.aimd_rate_control->GetNearMaxIncreaseRateBps(),
               1000);
-  EXPECT_EQ(kMinBwePeriodMs,
-            states.aimd_rate_control->GetExpectedBandwidthPeriodMs());
+  EXPECT_EQ(3000, states.aimd_rate_control->GetExpectedBandwidthPeriodMs());
 }
 
 TEST(AimdRateControlTest, BweLimitedByAckedBitrate) {
@@ -124,15 +124,15 @@ TEST(AimdRateControlTest, BweNotLimitedByDecreasingAckedBitrate) {
   EXPECT_EQ(new_estimate, prev_estimate);
 }
 
-TEST(AimdRateControlTest, MinPeriodUntilFirstOveruse) {
+TEST(AimdRateControlTest, DefaultPeriodUntilFirstOveruse) {
   auto states = CreateAimdRateControlStates();
   states.aimd_rate_control->SetStartBitrate(300000);
-  EXPECT_EQ(kMinBwePeriodMs,
+  EXPECT_EQ(kDefaultPeriodMs,
             states.aimd_rate_control->GetExpectedBandwidthPeriodMs());
   states.simulated_clock->AdvanceTimeMilliseconds(100);
-  UpdateRateControl(states, BandwidthUsage::kBwOverusing, 280000,
+  UpdateRateControl(states, BandwidthUsage::kBwOverusing, 100000,
                     states.simulated_clock->TimeInMilliseconds());
-  EXPECT_NE(kMinBwePeriodMs,
+  EXPECT_NE(kDefaultPeriodMs,
             states.aimd_rate_control->GetExpectedBandwidthPeriodMs());
 }
 
@@ -152,21 +152,6 @@ TEST(AimdRateControlTest, ExpectedPeriodAfter20kbpsDropAnd5kbpsIncrease) {
   EXPECT_EQ(4000, states.aimd_rate_control->GetExpectedBandwidthPeriodMs());
 }
 
-TEST(AimdRateControlTest, MinPeriodAfterLargeBitrateDecrease) {
-  auto states = CreateAimdRateControlStates();
-  constexpr int kInitialBitrate = 110000;
-  states.aimd_rate_control->SetEstimate(
-      kInitialBitrate, states.simulated_clock->TimeInMilliseconds());
-  states.simulated_clock->AdvanceTimeMilliseconds(100);
-  // Make such a large drop in bitrate that should be treated as network
-  // degradation.
-  constexpr int kAckedBitrate = kInitialBitrate * 3 / 4 / kFractionAfterOveruse;
-  UpdateRateControl(states, BandwidthUsage::kBwOverusing, kAckedBitrate,
-                    states.simulated_clock->TimeInMilliseconds());
-  EXPECT_EQ(kMinBwePeriodMs,
-            states.aimd_rate_control->GetExpectedBandwidthPeriodMs());
-}
-
 TEST(AimdRateControlTest, BandwidthPeriodIsNotBelowMin) {
   auto states = CreateAimdRateControlStates();
   constexpr int kInitialBitrate = 10000;
@@ -182,12 +167,12 @@ TEST(AimdRateControlTest, BandwidthPeriodIsNotBelowMin) {
 
 TEST(AimdRateControlTest, BandwidthPeriodIsNotAboveMax) {
   auto states = CreateAimdRateControlStates();
-  constexpr int kInitialBitrate = 50000000;
+  constexpr int kInitialBitrate = 10010000;
   states.aimd_rate_control->SetEstimate(
       kInitialBitrate, states.simulated_clock->TimeInMilliseconds());
   states.simulated_clock->AdvanceTimeMilliseconds(100);
   // Make a large (10 Mbps) bitrate drop to 10 kbps.
-  constexpr int kAckedBitrate = 40000000 / kFractionAfterOveruse;
+  constexpr int kAckedBitrate = 10000 / kFractionAfterOveruse;
   UpdateRateControl(states, BandwidthUsage::kBwOverusing, kAckedBitrate,
                     states.simulated_clock->TimeInMilliseconds());
   EXPECT_EQ(kMaxBwePeriodMs,