diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 18749e5..c0c9255 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -1104,6 +1104,10 @@
   int8_t nearest_past_ref;
   int8_t nearest_future_ref;
 
+  // Indicates the number of simple translation winner modes for exhaustive
+  // motion mode evaluation
+  int num_winner_motion_modes;
+
   // TODO(sdeng): consider merge the following arrays.
   double *tpl_rdmult_scaling_factors;
   double *tpl_sb_rdmult_scaling_factors;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 4140ac7..e1d92d4 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -9788,17 +9788,34 @@
   return mv_field_check_ctxt.mv_field_check_result;
 }
 
+static INLINE void update_mode_start_end_index(const AV1_COMP *const cpi,
+                                               int *mode_index_start,
+                                               int *mode_index_end,
+                                               int last_motion_mode_allowed,
+                                               int interintra_allowed,
+                                               int eval_motion_mode) {
+  *mode_index_start = (int)SIMPLE_TRANSLATION;
+  *mode_index_end = (int)last_motion_mode_allowed + interintra_allowed;
+  if (cpi->sf.motion_mode_for_winner_cand) {
+    if (!eval_motion_mode) {
+      *mode_index_end = (int)SIMPLE_TRANSLATION;
+    } else {
+      // Set the start index appropriately to process motion modes other than
+      // simple translation
+      *mode_index_start = 1;
+    }
+  }
+}
+
 // TODO(afergs): Refactor the MBMI references in here - there's four
 // TODO(afergs): Refactor optional args - add them to a struct or remove
-static int64_t motion_mode_rd(const AV1_COMP *const cpi, TileDataEnc *tile_data,
-                              MACROBLOCK *const x, BLOCK_SIZE bsize,
-                              RD_STATS *rd_stats, RD_STATS *rd_stats_y,
-                              RD_STATS *rd_stats_uv, int *disable_skip,
-                              HandleInterModeArgs *const args,
-                              int64_t ref_best_rd, const int *refs,
-                              int *rate_mv, const BUFFER_SET *orig_dst,
-                              int64_t *best_est_rd, int do_tx_search,
-                              InterModesInfo *inter_modes_info) {
+static int64_t motion_mode_rd(
+    const AV1_COMP *const cpi, TileDataEnc *tile_data, MACROBLOCK *const x,
+    BLOCK_SIZE bsize, RD_STATS *rd_stats, RD_STATS *rd_stats_y,
+    RD_STATS *rd_stats_uv, int *disable_skip, HandleInterModeArgs *const args,
+    int64_t ref_best_rd, const int *refs, int *rate_mv,
+    const BUFFER_SET *orig_dst, int64_t *best_est_rd, int do_tx_search,
+    InterModesInfo *inter_modes_info, int eval_motion_mode) {
   const AV1_COMMON *const cm = &cpi->common;
   const int num_planes = av1_num_planes(cm);
   MACROBLOCKD *xd = &x->e_mbd;
@@ -9850,8 +9867,11 @@
           : 0;
   const int mi_row = xd->mi_row;
   const int mi_col = xd->mi_col;
-  for (int mode_index = (int)SIMPLE_TRANSLATION;
-       mode_index <= (int)last_motion_mode_allowed + interintra_allowed;
+  int mode_index_start, mode_index_end;
+  update_mode_start_end_index(cpi, &mode_index_start, &mode_index_end,
+                              last_motion_mode_allowed, interintra_allowed,
+                              eval_motion_mode);
+  for (int mode_index = mode_index_start; mode_index <= mode_index_end;
        mode_index++) {
     if (args->skip_motion_mode && mode_index) continue;
     if (cpi->sf.prune_single_motion_modes_by_simple_trans &&
@@ -9921,7 +9941,7 @@
         mbmi->mv[0].as_int = x->best_mv.as_int;
         tmp_rate2 = rate2_nocoeff - rate_mv0 + tmp_rate_mv;
       }
-      if (mbmi->mv[0].as_int != cur_mv) {
+      if ((mbmi->mv[0].as_int != cur_mv) || eval_motion_mode) {
         av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, orig_dst, bsize,
                                       0, av1_num_planes(cm) - 1);
       }
@@ -10862,6 +10882,19 @@
   return result;
 }
 
+typedef struct motion_mode_candidate {
+  MB_MODE_INFO mbmi;
+  int rate_mv;
+  int rate2_nocoeff;
+  int skip_motion_mode;
+  int64_t rd_cost;
+} motion_mode_candidate;
+
+typedef struct motion_mode_best_st_candidate {
+  motion_mode_candidate motion_mode_cand[MAX_WINNER_MOTION_MODES];
+  int num_motion_mode_cand;
+} motion_mode_best_st_candidate;
+
 static int64_t handle_inter_mode(AV1_COMP *const cpi, TileDataEnc *tile_data,
                                  MACROBLOCK *x, BLOCK_SIZE bsize,
                                  RD_STATS *rd_stats, RD_STATS *rd_stats_y,
@@ -10870,7 +10903,8 @@
                                  uint8_t *const tmp_buf,
                                  const CompoundTypeRdBuffers *rd_buffers,
                                  int64_t *best_est_rd, const int do_tx_search,
-                                 InterModesInfo *inter_modes_info) {
+                                 InterModesInfo *inter_modes_info,
+                                 motion_mode_candidate *motion_mode_cand) {
   const AV1_COMMON *cm = &cpi->common;
   const int num_planes = av1_num_planes(cm);
   MACROBLOCKD *xd = &x->e_mbd;
@@ -11014,6 +11048,7 @@
                   if (best_mbmi.ref_mv_idx == i) {
                     assert(best_rd != INT64_MAX);
                     best_mbmi.ref_mv_idx = ref_mv_idx;
+                    motion_mode_cand->rate_mv = this_rate_mv;
                     best_rd_stats.rate += this_cost - compare_cost;
                     best_rd = RDCOST(x->rdmult, best_rd_stats.rate,
                                      best_rd_stats.dist);
@@ -11172,10 +11207,11 @@
 #if CONFIG_COLLECT_COMPONENT_TIMING
     start_timing(cpi, motion_mode_rd_time);
 #endif
+    int rate2_nocoeff = rd_stats->rate;
     ret_val = motion_mode_rd(cpi, tile_data, x, bsize, rd_stats, rd_stats_y,
                              rd_stats_uv, disable_skip, args, ref_best_rd, refs,
                              &rate_mv, &orig_dst, best_est_rd, do_tx_search,
-                             inter_modes_info);
+                             inter_modes_info, 0);
 #if CONFIG_COLLECT_COMPONENT_TIMING
     end_timing(cpi, motion_mode_rd_time);
 #endif
@@ -11196,6 +11232,8 @@
         memcpy(best_blk_skip, x->blk_skip,
                sizeof(best_blk_skip[0]) * xd->n4_h * xd->n4_w);
         av1_copy_array(best_tx_type_map, xd->tx_type_map, xd->n4_h * xd->n4_w);
+        motion_mode_cand->rate_mv = rate_mv;
+        motion_mode_cand->rate2_nocoeff = rate2_nocoeff;
       }
 
       if (tmp_rd < ref_best_rd) {
@@ -13012,6 +13050,79 @@
          ref_frame_rd[frame2] <= ref_frame_rd[0];
 }
 
+static AOM_INLINE void evaluate_motion_mode_for_winner_candidates(
+    const AV1_COMP *const cpi, MACROBLOCK *const x, RD_STATS *const rd_cost,
+    HandleInterModeArgs *const args, TileDataEnc *const tile_data,
+    PICK_MODE_CONTEXT *const ctx,
+    struct buf_2d yv12_mb[REF_FRAMES][MAX_MB_PLANE],
+    const motion_mode_best_st_candidate *const best_motion_mode_cands,
+    int do_tx_search, const BLOCK_SIZE bsize, int64_t *const best_est_rd,
+    InterModeSearchState *const search_state) {
+  const AV1_COMMON *const cm = &cpi->common;
+  const int num_planes = av1_num_planes(cm);
+  MACROBLOCKD *const xd = &x->e_mbd;
+  MB_MODE_INFO *const mbmi = xd->mi[0];
+  InterModesInfo *const inter_modes_info = x->inter_modes_info;
+  const int num_best_cand = best_motion_mode_cands->num_motion_mode_cand;
+
+  for (int cand = 0; cand < num_best_cand; cand++) {
+    RD_STATS rd_stats;
+    RD_STATS rd_stats_y;
+    RD_STATS rd_stats_uv;
+    av1_init_rd_stats(&rd_stats);
+    av1_init_rd_stats(&rd_stats_y);
+    av1_init_rd_stats(&rd_stats_uv);
+    int disable_skip = 0, rate_mv;
+
+    rate_mv = best_motion_mode_cands->motion_mode_cand[cand].rate_mv;
+    args->skip_motion_mode =
+        best_motion_mode_cands->motion_mode_cand[cand].skip_motion_mode;
+    *mbmi = best_motion_mode_cands->motion_mode_cand[cand].mbmi;
+    rd_stats.rate =
+        best_motion_mode_cands->motion_mode_cand[cand].rate2_nocoeff;
+
+    // Continue if the best candidate is compound.
+    if (!is_inter_singleref_mode(mbmi->mode)) continue;
+
+    x->skip = 0;
+    const int mode_index = get_prediction_mode_idx(
+        mbmi->mode, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+    int refs[2] = { mbmi->ref_frame[0],
+                    (mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) };
+    struct macroblockd_plane *p = xd->plane;
+    const BUFFER_SET orig_dst = {
+      { p[0].dst.buf, p[1].dst.buf, p[2].dst.buf },
+      { p[0].dst.stride, p[1].dst.stride, p[2].dst.stride },
+    };
+
+    set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+    args->simple_rd_state = x->simple_rd_state[mode_index];
+    // Initialize motion mode to simple translation
+    // Calculation of switchable rate depends on it.
+    mbmi->motion_mode = 0;
+    const int is_comp_pred = mbmi->ref_frame[1] > INTRA_FRAME;
+    for (int i = 0; i < num_planes; i++) {
+      xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
+      if (is_comp_pred) xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i];
+    }
+
+    int64_t ret_value = motion_mode_rd(
+        cpi, tile_data, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv,
+        &disable_skip, args, search_state->best_rd, refs, &rate_mv, &orig_dst,
+        best_est_rd, do_tx_search, inter_modes_info, 1);
+
+    if (ret_value != INT64_MAX) {
+      rd_stats.rdcost = RDCOST(x->rdmult, rd_stats.rate, rd_stats.dist);
+      if (rd_stats.rdcost < search_state->best_rd) {
+        const THR_MODES mode_enum = get_prediction_mode_idx(
+            mbmi->mode, mbmi->ref_frame[0], mbmi->ref_frame[1]);
+        update_search_state(search_state, rd_cost, ctx, &rd_stats, &rd_stats_y,
+                            &rd_stats_uv, mode_enum, x, do_tx_search);
+      }
+    }
+  }
+}
+
 void av1_rd_pick_inter_mode_sb(AV1_COMP *cpi, TileDataEnc *tile_data,
                                MACROBLOCK *x, RD_STATS *rd_cost,
                                const BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
@@ -13049,6 +13160,14 @@
                                NULL,
                                { { { 0 }, { { 0 } }, { 0 }, 0, 0, 0, 0 } },
                                0 };
+  const int max_winner_motion_mode_cand = cpi->num_winner_motion_modes;
+  motion_mode_candidate motion_mode_cand;
+  motion_mode_best_st_candidate best_motion_mode_cands;
+  // Initializing the number of motion mode candidates to zero.
+  best_motion_mode_cands.num_motion_mode_cand = 0;
+  for (i = 0; i < MAX_WINNER_MOTION_MODES; ++i)
+    best_motion_mode_cands.motion_mode_cand[i].rd_cost = INT64_MAX;
+
   for (i = 0; i < REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
 
   av1_invalid_rd_stats(rd_cost);
@@ -13267,7 +13386,7 @@
     int64_t this_rd = handle_inter_mode(
         cpi, tile_data, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv,
         &disable_skip, &args, ref_best_rd, tmp_buf, &x->comp_rd_buffer,
-        &best_est_rd, do_tx_search, inter_modes_info);
+        &best_est_rd, do_tx_search, inter_modes_info, &motion_mode_cand);
 
     if (sf->prune_comp_search_by_single_result > 0 &&
         is_inter_singleref_mode(this_mode) && args.single_ref_first_pass) {
@@ -13294,6 +13413,41 @@
       update_search_state(&search_state, rd_cost, ctx, &rd_stats, &rd_stats_y,
                           &rd_stats_uv, mode_enum, x, do_tx_search);
     }
+    if (cpi->sf.motion_mode_for_winner_cand) {
+      const int num_motion_mode_cand =
+          best_motion_mode_cands.num_motion_mode_cand;
+      int valid_motion_mode_cand_loc =
+          (num_motion_mode_cand > 0) ? INT32_MAX : 0;
+
+      // find the best location to insert new motion mode candidate
+      for (int j = 0; j < num_motion_mode_cand; j++) {
+        if (this_rd < best_motion_mode_cands.motion_mode_cand[j].rd_cost) {
+          valid_motion_mode_cand_loc = j;
+          break;
+        }
+      }
+
+      if (valid_motion_mode_cand_loc < max_winner_motion_mode_cand) {
+        if (num_motion_mode_cand > 0 &&
+            valid_motion_mode_cand_loc < max_winner_motion_mode_cand - 1)
+          memmove(
+              &best_motion_mode_cands
+                   .motion_mode_cand[valid_motion_mode_cand_loc + 1],
+              &best_motion_mode_cands
+                   .motion_mode_cand[valid_motion_mode_cand_loc],
+              (AOMMIN(num_motion_mode_cand, max_winner_motion_mode_cand - 1) -
+               valid_motion_mode_cand_loc) *
+                  sizeof(best_motion_mode_cands.motion_mode_cand[0]));
+        motion_mode_cand.mbmi = *mbmi;
+        motion_mode_cand.rd_cost = this_rd;
+        motion_mode_cand.skip_motion_mode = args.skip_motion_mode;
+        best_motion_mode_cands.motion_mode_cand[valid_motion_mode_cand_loc] =
+            motion_mode_cand;
+        best_motion_mode_cands.num_motion_mode_cand =
+            AOMMIN(max_winner_motion_mode_cand,
+                   best_motion_mode_cands.num_motion_mode_cand + 1);
+      }
+    }
 
     /* keep record of best compound/single-only prediction */
     if (!disable_skip) {
@@ -13328,6 +13482,15 @@
     if (x->skip && !comp_pred) break;
   }
 
+  if (cpi->sf.motion_mode_for_winner_cand) {
+    // For the single ref winner candidates, evaluate other motion modes (non
+    // simple translation).
+    evaluate_motion_mode_for_winner_candidates(
+        cpi, x, rd_cost, &args, tile_data, ctx, yv12_mb,
+        &best_motion_mode_cands, do_tx_search, bsize, &best_est_rd,
+        &search_state);
+  }
+
 #if CONFIG_COLLECT_COMPONENT_TIMING
   start_timing(cpi, do_tx_search_time);
 #endif
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 3bef55d..add4e41 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -31,6 +31,7 @@
 #define INTER_INTRA_RD_THRESH_SHIFT 4
 #define COMP_TYPE_RD_THRESH_SCALE 11
 #define COMP_TYPE_RD_THRESH_SHIFT 4
+#define MAX_WINNER_MOTION_MODES 10
 
 struct TileInfo;
 struct macroblock;
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index 4979c95..6596384 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -68,6 +68,9 @@
                                                                  { 1, 2, 0 },
                                                                  { 2, 2, 0 } };
 
+// Indicates number of winner simple translation modes to be used
+static unsigned int num_winner_motion_modes[3] = { 0, 10, 3 };
+
 // Threshold values to be used for disabling coeff RD-optimization
 // based on block MSE
 // TODO(any): Experiment the threshold logic based on variance metric
@@ -407,6 +410,11 @@
     sf->mv.subpel_search_method = SUBPEL_TREE_PRUNED;
     sf->simple_motion_search_prune_agg = 1;
     sf->disable_sb_level_mv_cost_upd = 1;
+    sf->motion_mode_for_winner_cand =
+        boosted
+            ? 0
+            : gf_group->update_type[gf_group->index] == INTNL_ARF_UPDATE ? 1
+                                                                         : 2;
     sf->tx_type_search.use_skip_flag_prediction =
         cm->allow_screen_content_tools ? 1 : 2;
   }
@@ -857,6 +865,7 @@
   sf->adaptive_overlay_encoding = 1;
   sf->skip_interp_filter_search = 0;
   sf->force_tx_search_off = 0;
+  sf->motion_mode_for_winner_cand = 0;
   sf->num_inter_modes_for_tx_search = INT_MAX;
 
   for (i = 0; i < TX_SIZES; i++) {
@@ -1028,6 +1037,11 @@
          tx_domain_dist_types[cpi->sf.tx_domain_dist_level],
          sizeof(cpi->use_transform_domain_distortion));
 
+  // Update the number of winner motion modes to be used appropriately
+  cpi->num_winner_motion_modes =
+      num_winner_motion_modes[cpi->sf.motion_mode_for_winner_cand];
+  assert(cpi->num_winner_motion_modes <= MAX_WINNER_MOTION_MODES);
+
   // assert ensures that coeff_opt_dist_thresholds is accessed correctly
   assert(cpi->sf.perform_coeff_opt >= 0 && cpi->sf.perform_coeff_opt < 5);
   memcpy(cpi->coeff_opt_dist_threshold,
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index d4e9070..eca84e9 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -831,6 +831,11 @@
 
   // Disable interinter_wedge
   int disable_interinter_wedge;
+
+  // Motion mode for winner candidates:
+  // 0: speed feature OFF
+  // 1 / 2 : Use configured number of winner candidates
+  int motion_mode_for_winner_cand;
 } SPEED_FEATURES;
 
 struct AV1_COMP;
diff --git a/build/cmake/aom_configure.cmake b/build/cmake/aom_configure.cmake
index a89336b..6705c9f 100644
--- a/build/cmake/aom_configure.cmake
+++ b/build/cmake/aom_configure.cmake
@@ -291,7 +291,7 @@
     add_c_flag_if_supported("-Wstack-usage=170000")
     add_cxx_flag_if_supported("-Wstack-usage=270000")
   elseif(CONFIG_RD_DEBUG) # Another case where higher stack usage is expected.
-    add_c_flag_if_supported("-Wstack-usage=111000")
+    add_c_flag_if_supported("-Wstack-usage=117000")
     add_cxx_flag_if_supported("-Wstack-usage=240000")
   else()
     add_c_flag_if_supported("-Wstack-usage=100000")