diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 199074c..83c4960 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -443,6 +443,11 @@
   // Strong color activity detection. Used in REALTIME coding mode to enhance
   // the visual quality at the boundary of moving color objects.
   uint8_t color_sensitivity[2];
+
+  // Used to control the tx size search evaluation for mode processing
+  // (normal/winner mode)
+  int tx_size_search_method;
+  TX_MODE tx_mode;
 };
 
 static INLINE int is_rect_tx_allowed_bsize(BLOCK_SIZE bsize) {
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 5f93c21..93d8de7 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -762,6 +762,7 @@
   // coefficients for mode decision
   x->coeff_opt_dist_threshold =
       get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold, 0, 0);
+  set_tx_size_search_method(cpi, x, 0, 1);
 
   // Save rdmult before it might be changed, so it can be restored later.
   const int orig_rdmult = x->rdmult;
@@ -4200,17 +4201,6 @@
                          cm->seq_params.subsampling_y, num_planes);
 }
 
-static TX_MODE select_tx_mode(const AV1_COMP *cpi) {
-  if (cpi->common.coded_lossless) return ONLY_4X4;
-  if (cpi->sf.tx_size_search_method == USE_LARGESTALL)
-    return TX_MODE_LARGEST;
-  else if (cpi->sf.tx_size_search_method == USE_FULL_RD ||
-           cpi->sf.tx_size_search_method == USE_FAST_RD)
-    return TX_MODE_SELECT;
-  else
-    return cpi->common.tx_mode;
-}
-
 void av1_alloc_tile_data(AV1_COMP *cpi) {
   AV1_COMMON *const cm = &cpi->common;
   const int tile_cols = cm->tile_cols;
@@ -4695,7 +4685,7 @@
   cm->coded_lossless = is_coded_lossless(cm, xd);
   cm->all_lossless = cm->coded_lossless && !av1_superres_scaled(cm);
 
-  cm->tx_mode = select_tx_mode(cpi);
+  cm->tx_mode = select_tx_mode(cpi, cpi->sf.tx_size_search_method);
 
   // Fix delta q resolution for the moment
   cm->delta_q_info.delta_q_res = 0;
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c
index 2c72345..e3542da 100644
--- a/av1/encoder/nonrd_pickmode.c
+++ b/av1/encoder/nonrd_pickmode.c
@@ -499,13 +499,14 @@
 }
 
 static TX_SIZE calculate_tx_size(const AV1_COMP *const cpi, BLOCK_SIZE bsize,
-                                 MACROBLOCKD *const xd, unsigned int var,
+                                 MACROBLOCK *const x, unsigned int var,
                                  unsigned int sse) {
+  MACROBLOCKD *const xd = &x->e_mbd;
   TX_SIZE tx_size;
-  if (cpi->common.tx_mode == TX_MODE_SELECT) {
+  if (x->tx_mode == TX_MODE_SELECT) {
     if (sse > (var << 2))
       tx_size = AOMMIN(max_txsize_lookup[bsize],
-                       tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
+                       tx_mode_to_biggest_tx_size[x->tx_mode]);
     else
       tx_size = TX_8X8;
 
@@ -516,7 +517,7 @@
       tx_size = TX_16X16;
   } else {
     tx_size = AOMMIN(max_txsize_lookup[bsize],
-                     tx_mode_to_biggest_tx_size[cpi->common.tx_mode]);
+                     tx_mode_to_biggest_tx_size[x->tx_mode]);
   }
   if (bsize > BLOCK_32X32) tx_size = TX_16X16;
   return AOMMIN(tx_size, TX_16X16);
@@ -623,7 +624,7 @@
   ac_thr *= ac_thr_factor(cpi->oxcf.speed, cpi->common.width,
                           cpi->common.height, abs(sum) >> (bw + bh));
 
-  tx_size = calculate_tx_size(cpi, bsize, xd, var, sse);
+  tx_size = calculate_tx_size(cpi, bsize, x, var, sse);
   // The code below for setting skip flag assumes tranform size of at least 8x8,
   // so force this lower limit on transform.
   if (tx_size < TX_8X8) tx_size = TX_8X8;
@@ -703,7 +704,7 @@
 
   unsigned int var = cpi->fn_ptr[bsize].vf(p->src.buf, p->src.stride,
                                            pd->dst.buf, pd->dst.stride, &sse);
-  xd->mi[0]->tx_size = calculate_tx_size(cpi, bsize, xd, var, sse);
+  xd->mi[0]->tx_size = calculate_tx_size(cpi, bsize, x, var, sse);
 
   if (cpi->sf.use_modeled_non_rd_cost) {
     const int bwide = block_size_wide[bsize];
@@ -1322,7 +1323,7 @@
     init_mbmi(mi, this_mode, ref_frame, NONE_FRAME, cm);
 
     mi->tx_size = AOMMIN(AOMMIN(max_txsize_lookup[bsize],
-                                tx_mode_to_biggest_tx_size[cm->tx_mode]),
+                                tx_mode_to_biggest_tx_size[x->tx_mode]),
                          TX_16X16);
     memset(mi->inter_tx_size, mi->tx_size, sizeof(mi->inter_tx_size));
     memset(mi->txk_type, DCT_DCT, sizeof(mi->txk_type[0]) * TXK_TYPE_BUF_LEN);
@@ -1624,7 +1625,7 @@
     PRED_BUFFER *const best_pred = best_pickmode.best_pred;
     TX_SIZE intra_tx_size =
         AOMMIN(AOMMIN(max_txsize_lookup[bsize],
-                      tx_mode_to_biggest_tx_size[cpi->common.tx_mode]),
+                      tx_mode_to_biggest_tx_size[x->tx_mode]),
                TX_16X16);
 
     if (reuse_inter_pred && best_pred != NULL) {
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 3476a37..ff1a3c8 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -3500,10 +3500,10 @@
   }
 }
 
-static int tx_size_cost(const AV1_COMMON *const cm, const MACROBLOCK *const x,
-                        BLOCK_SIZE bsize, TX_SIZE tx_size) {
+static int tx_size_cost(const MACROBLOCK *const x, BLOCK_SIZE bsize,
+                        TX_SIZE tx_size) {
   assert(bsize == x->e_mbd.mi[0]->sb_type);
-  if (cm->tx_mode != TX_MODE_SELECT || !block_signals_txsize(bsize)) return 0;
+  if (x->tx_mode != TX_MODE_SELECT || !block_signals_txsize(bsize)) return 0;
 
   const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize);
   const int depth = tx_size_to_depth(tx_size, bsize);
@@ -3516,7 +3516,6 @@
                         RD_STATS *rd_stats, int64_t ref_best_rd, BLOCK_SIZE bs,
                         TX_SIZE tx_size, FAST_TX_SEARCH_MODE ftxs_mode,
                         int skip_trellis) {
-  const AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = xd->mi[0];
   int64_t rd = INT64_MAX;
@@ -3524,11 +3523,11 @@
   int s0, s1;
   const int is_inter = is_inter_block(mbmi);
   const int tx_select =
-      cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(mbmi->sb_type);
+      x->tx_mode == TX_MODE_SELECT && block_signals_txsize(mbmi->sb_type);
   int ctx = txfm_partition_context(
       xd->above_txfm_context, xd->left_txfm_context, mbmi->sb_type, tx_size);
-  const int r_tx_size = is_inter ? x->txfm_partition_cost[ctx][0]
-                                 : tx_size_cost(cm, x, bs, tx_size);
+  const int r_tx_size =
+      is_inter ? x->txfm_partition_cost[ctx][0] : tx_size_cost(x, bs, tx_size);
 
   assert(IMPLIES(is_rect_tx(tx_size), is_rect_tx_allowed_bsize(bs)));
 
@@ -3610,10 +3609,9 @@
 static void choose_largest_tx_size(const AV1_COMP *const cpi, MACROBLOCK *x,
                                    RD_STATS *rd_stats, int64_t ref_best_rd,
                                    BLOCK_SIZE bs) {
-  const AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = xd->mi[0];
-  mbmi->tx_size = tx_size_from_tx_mode(bs, cm->tx_mode);
+  mbmi->tx_size = tx_size_from_tx_mode(bs, x->tx_mode);
   const int skip_ctx = av1_get_skip_context(xd);
   int s0, s1;
 
@@ -3646,8 +3644,9 @@
 }
 
 static int get_search_init_depth(int mi_width, int mi_height, int is_inter,
-                                 const SPEED_FEATURES *sf) {
-  if (sf->tx_size_search_method == USE_LARGESTALL) return MAX_VARTX_DEPTH;
+                                 const SPEED_FEATURES *sf,
+                                 int tx_size_search_method) {
+  if (tx_size_search_method == USE_LARGESTALL) return MAX_VARTX_DEPTH;
 
   if (sf->tx_size_search_lgr_block) {
     if (mi_width > mi_size_wide[BLOCK_64X64] ||
@@ -3669,20 +3668,20 @@
                                         int64_t ref_best_rd, BLOCK_SIZE bs) {
   av1_invalid_rd_stats(rd_stats);
 
-  const AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = xd->mi[0];
   const TX_SIZE max_rect_tx_size = max_txsize_rect_lookup[bs];
-  const int tx_select = cm->tx_mode == TX_MODE_SELECT;
+  const int tx_select = x->tx_mode == TX_MODE_SELECT;
   int start_tx;
   int depth, init_depth;
 
   if (tx_select) {
     start_tx = max_rect_tx_size;
     init_depth = get_search_init_depth(mi_size_wide[bs], mi_size_high[bs],
-                                       is_inter_block(mbmi), &cpi->sf);
+                                       is_inter_block(mbmi), &cpi->sf,
+                                       x->tx_size_search_method);
   } else {
-    const TX_SIZE chosen_tx_size = tx_size_from_tx_mode(bs, cm->tx_mode);
+    const TX_SIZE chosen_tx_size = tx_size_from_tx_mode(bs, x->tx_mode);
     start_tx = chosen_tx_size;
     init_depth = MAX_TX_DEPTH;
   }
@@ -3968,7 +3967,7 @@
 
   if (xd->lossless[xd->mi[0]->segment_id]) {
     choose_smallest_tx_size(cpi, x, rd_stats, ref_best_rd, bs);
-  } else if (cpi->sf.tx_size_search_method == USE_LARGESTALL) {
+  } else if (x->tx_size_search_method == USE_LARGESTALL) {
     choose_largest_tx_size(cpi, x, rd_stats, ref_best_rd, bs);
   } else {
     choose_tx_size_type_from_rd(cpi, x, rd_stats, ref_best_rd, bs);
@@ -4108,7 +4107,7 @@
   RD_STATS this_rd_stats;
   int row, col;
   int64_t temp_sse, this_rd;
-  TX_SIZE tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode);
+  TX_SIZE tx_size = tx_size_from_tx_mode(bsize, x->tx_mode);
   const int stepr = tx_size_high_unit[tx_size];
   const int stepc = tx_size_wide_unit[tx_size];
   const int max_blocks_wide = max_block_wide(xd, bsize, 0);
@@ -4236,8 +4235,7 @@
   int this_rate = tokenonly_rd_stats.rate + palette_mode_cost;
   int64_t this_rd = RDCOST(x->rdmult, this_rate, tokenonly_rd_stats.dist);
   if (!xd->lossless[mbmi->segment_id] && block_signals_txsize(mbmi->sb_type)) {
-    tokenonly_rd_stats.rate -=
-        tx_size_cost(&cpi->common, x, bsize, mbmi->tx_size);
+    tokenonly_rd_stats.rate -= tx_size_cost(x, bsize, mbmi->tx_size);
   }
   if (this_rd < *best_rd) {
     *best_rd = this_rd;
@@ -4689,7 +4687,7 @@
     // tokenonly rate, but for intra blocks, tx_size is always coded
     // (prediction granularity), so we account for it in the full rate,
     // not the tokenonly rate.
-    this_rate_tokenonly -= tx_size_cost(&cpi->common, x, bsize, mbmi->tx_size);
+    this_rate_tokenonly -= tx_size_cost(x, bsize, mbmi->tx_size);
   }
   const int this_rate =
       rd_stats.rate +
@@ -4757,6 +4755,9 @@
   x->coeff_opt_dist_threshold =
       get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold,
                               cpi->sf.enable_winner_mode_for_coeff_opt, 0);
+  // Set the transform size search method for mode evaluation
+  set_tx_size_search_method(cpi, x, cpi->sf.enable_winner_mode_for_tx_size_srch,
+                            0);
 
   MB_MODE_INFO best_mbmi = *mbmi;
   /* Y Search for intra prediction mode */
@@ -4800,8 +4801,7 @@
       // tokenonly rate, but for intra blocks, tx_size is always coded
       // (prediction granularity), so we account for it in the full rate,
       // not the tokenonly rate.
-      this_rate_tokenonly -=
-          tx_size_cost(&cpi->common, x, bsize, mbmi->tx_size);
+      this_rate_tokenonly -= tx_size_cost(x, bsize, mbmi->tx_size);
     }
     this_rate =
         this_rd_stats.rate +
@@ -4838,15 +4838,20 @@
   // If previous searches use only the default tx type/no R-D optimization of
   // quantized coeffs, do an extra search for the best tx type/better R-D
   // optimization of quantized coeffs
+  // TODO(any) : Refactor the winner mode evaluation check control code
   if ((cpi->sf.tx_type_search.fast_intra_tx_type_search &&
        !cpi->oxcf.use_intra_default_tx_only) ||
       (cpi->sf.enable_winner_mode_for_coeff_opt &&
        (cpi->optimize_seg_arr[mbmi->segment_id] != NO_TRELLIS_OPT &&
-        cpi->optimize_seg_arr[mbmi->segment_id] != FINAL_PASS_TRELLIS_OPT))) {
+        cpi->optimize_seg_arr[mbmi->segment_id] != FINAL_PASS_TRELLIS_OPT)) ||
+      cpi->sf.enable_winner_mode_for_tx_size_srch) {
     // Get the threshold for R-D optimization of coefficients for winner mode
     x->coeff_opt_dist_threshold =
         get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold,
                                 cpi->sf.enable_winner_mode_for_coeff_opt, 1);
+    // Set the transform size search method for winner mode processing
+    set_tx_size_search_method(cpi, x,
+                              cpi->sf.enable_winner_mode_for_tx_size_srch, 1);
     *mbmi = best_mbmi;
     x->use_default_intra_tx_type = 0;
     intra_block_yrd(cpi, x, bsize, bmode_costs, &best_rd, rate, rate_tokenonly,
@@ -5310,7 +5315,7 @@
   // will use more complex search given that the transform partitions have
   // already been decided.
 
-  const int fast_tx_search = cpi->sf.tx_size_search_method > USE_FULL_RD;
+  const int fast_tx_search = x->tx_size_search_method > USE_FULL_RD;
   int64_t rd_thresh = ref_best_rd;
   if (fast_tx_search && rd_thresh < INT64_MAX) {
     if (INT64_MAX - rd_thresh > (rd_thresh >> 3)) rd_thresh += (rd_thresh >> 3);
@@ -5336,8 +5341,8 @@
   const int skip_ctx = av1_get_skip_context(xd);
   const int s0 = x->skip_cost[skip_ctx][0];
   const int s1 = x->skip_cost[skip_ctx][1];
-  const int init_depth =
-      get_search_init_depth(mi_width, mi_height, 1, &cpi->sf);
+  const int init_depth = get_search_init_depth(mi_width, mi_height, 1, &cpi->sf,
+                                               x->tx_size_search_method);
   const TX_SIZE max_tx_size = max_txsize_rect_lookup[plane_bsize];
   const int bh = tx_size_high_unit[max_tx_size];
   const int bw = tx_size_wide_unit[max_tx_size];
@@ -5512,8 +5517,8 @@
     const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 0);
     const int bh = tx_size_high_unit[max_tx_size];
     const int bw = tx_size_wide_unit[max_tx_size];
-    const int init_depth =
-        get_search_init_depth(mi_width, mi_height, 1, &cpi->sf);
+    const int init_depth = get_search_init_depth(
+        mi_width, mi_height, 1, &cpi->sf, x->tx_size_search_method);
     int idx, idy;
     int block = 0;
     int step = tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
@@ -8933,7 +8938,7 @@
 
   // cost and distortion
   av1_subtract_plane(x, bsize, 0);
-  if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
+  if (x->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
     pick_tx_size_type_yrd(cpi, x, rd_stats_y, bsize, mi_row, mi_col, rd_thresh);
 #if CONFIG_COLLECT_RD_STATS == 2
     PrintPredictionUnitStats(cpi, tile_data, x, rd_stats_y, bsize);
@@ -11002,6 +11007,8 @@
   // decision
   x->coeff_opt_dist_threshold =
       get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold, 0, 0);
+  // Set the transform size search method for mode evaluation
+  set_tx_size_search_method(cpi, x, 0, 0);
 
   if (intra_yrd < best_rd) {
     // Only store reconstructed luma when there's chroma RDO. When there's no
@@ -11219,7 +11226,7 @@
 
     // Set up tx_size related variables for skip-specific loop filtering.
     search_state->best_mbmode.tx_size =
-        block_signals_txsize(bsize) ? tx_size_from_tx_mode(bsize, cm->tx_mode)
+        block_signals_txsize(bsize) ? tx_size_from_tx_mode(bsize, x->tx_mode)
                                     : max_txsize_rect_lookup[bsize];
     memset(search_state->best_mbmode.inter_tx_size,
            search_state->best_mbmode.tx_size,
@@ -11276,6 +11283,7 @@
   MB_MODE_INFO *const mbmi = xd->mi[0];
   const int num_planes = av1_num_planes(cm);
 
+  // TODO(any) : Refactor the winner mode evaluation check control code
   if (xd->lossless[mbmi->segment_id] == 0 && best_mode_index >= 0 &&
       ((sf->tx_type_search.fast_inter_tx_type_search &&
         !cpi->oxcf.use_inter_dct_only && is_inter_mode(best_mbmode->mode)) ||
@@ -11284,7 +11292,8 @@
         !is_inter_mode(best_mbmode->mode)) ||
        (cpi->sf.enable_winner_mode_for_coeff_opt &&
         (cpi->optimize_seg_arr[mbmi->segment_id] != NO_TRELLIS_OPT &&
-         cpi->optimize_seg_arr[mbmi->segment_id] != FINAL_PASS_TRELLIS_OPT)))) {
+         cpi->optimize_seg_arr[mbmi->segment_id] != FINAL_PASS_TRELLIS_OPT)) ||
+       cpi->sf.enable_winner_mode_for_tx_size_srch)) {
     int skip_blk = 0;
     RD_STATS rd_stats_y, rd_stats_uv;
     const int skip_ctx = av1_get_skip_context(xd);
@@ -11296,6 +11305,9 @@
     x->coeff_opt_dist_threshold =
         get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold,
                                 cpi->sf.enable_winner_mode_for_coeff_opt, 1);
+    // Set the transform size search method for winner mode processing
+    set_tx_size_search_method(cpi, x,
+                              cpi->sf.enable_winner_mode_for_tx_size_srch, 1);
 
     *mbmi = *best_mbmode;
 
@@ -11315,7 +11327,7 @@
         av1_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col);
 
       av1_subtract_plane(x, bsize, 0);
-      if (cm->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
+      if (x->tx_mode == TX_MODE_SELECT && !xd->lossless[mbmi->segment_id]) {
         pick_tx_size_type_yrd(cpi, x, &rd_stats_y, bsize, mi_row, mi_col,
                               INT64_MAX);
         assert(rd_stats_y.rate != INT_MAX);
@@ -11700,6 +11712,9 @@
   x->coeff_opt_dist_threshold =
       get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold,
                               cpi->sf.enable_winner_mode_for_coeff_opt, 0);
+  // Set the transform size search method for mode evaluation
+  set_tx_size_search_method(cpi, x, cpi->sf.enable_winner_mode_for_tx_size_srch,
+                            0);
 
   if (cpi->sf.skip_repeat_interpolation_filter_search) {
     x->interp_filter_stats_idx[0] = 0;
@@ -12310,7 +12325,7 @@
     // tokenonly rate, but for intra blocks, tx_size is always coded
     // (prediction granularity), so we account for it in the full rate,
     // not the tokenonly rate.
-    rd_stats_y->rate -= tx_size_cost(cm, x, bsize, mbmi->tx_size);
+    rd_stats_y->rate -= tx_size_cost(x, bsize, mbmi->tx_size);
   }
   if (num_planes > 1 && !x->skip_chroma_rd) {
     const int uv_mode_cost =
@@ -13158,6 +13173,8 @@
   // Get the threshold for R-D optimization of coefficients for mode evaluation
   x->coeff_opt_dist_threshold =
       get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold, 0, 0);
+  // Set the transform size search method for winner mode processing
+  set_tx_size_search_method(cpi, x, 0, 0);
 
   // Only try palette mode when the best mode so far is an intra mode.
   const int try_palette =
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 9fb7f5d..9441caf 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -217,6 +217,29 @@
          USABLE_REF_MV_STACK_SIZE * sizeof(xd->ref_mv_stack[0][0]));
 }
 
+static TX_MODE select_tx_mode(
+    const AV1_COMP *cpi, const TX_SIZE_SEARCH_METHOD tx_size_search_method) {
+  if (cpi->common.coded_lossless) return ONLY_4X4;
+  if (tx_size_search_method == USE_LARGESTALL)
+    return TX_MODE_LARGEST;
+  else if (tx_size_search_method == USE_FULL_RD ||
+           tx_size_search_method == USE_FAST_RD)
+    return TX_MODE_SELECT;
+  else
+    return cpi->common.tx_mode;
+}
+
+static INLINE void set_tx_size_search_method(
+    const struct AV1_COMP *cpi, MACROBLOCK *x,
+    int enable_winner_mode_for_tx_size_srch, int is_winner_mode) {
+  // Populate transform size search method/transform mode appropriately
+  if (enable_winner_mode_for_tx_size_srch && !is_winner_mode) {
+    x->tx_size_search_method = USE_LARGESTALL;
+  } else {
+    x->tx_size_search_method = cpi->sf.tx_size_search_method;
+  }
+  x->tx_mode = select_tx_mode(cpi, x->tx_size_search_method);
+}
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index f0c3ce4..d60b2cb 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -342,7 +342,6 @@
 
   if (speed >= 3) {
     sf->reduce_inter_modes = boosted ? 1 : 2;
-    sf->tx_size_search_method = boosted ? USE_FULL_RD : USE_LARGESTALL;
     sf->less_rectangular_check_level = 2;
     // adaptive_motion_search breaks encoder multi-thread tests.
     // The values in x->pred_mv[] differ for single and multi-thread cases.
@@ -368,7 +367,12 @@
         !frame_is_intra_only(&cpi->common) || (cpi->rc.frames_to_key != 1);
     // TODO(any): Experiment on the dependency of this speed feature with
     // use_intra_txb_hash, use_inter_txb_hash and use_mb_rd_hash speed features
+    // TODO(any): Refactor the code related to following winner mode speed
+    // features
     sf->enable_winner_mode_for_coeff_opt = 1;
+    // TODO(any): Experiment with this speed feature by enabling for key frames
+    sf->enable_winner_mode_for_tx_size_srch =
+        frame_is_intra_only(&cpi->common) ? 0 : 1;
     sf->reduce_wiener_window_size = is_boosted_arf2_bwd_type ? 0 : 1;
     sf->mv.subpel_search_method = SUBPEL_TREE_PRUNED;
   }
@@ -859,6 +863,7 @@
   sf->disable_wedge_interintra_search = 0;
   sf->perform_coeff_opt = 0;
   sf->enable_winner_mode_for_coeff_opt = 0;
+  sf->enable_winner_mode_for_tx_size_srch = 0;
   sf->prune_comp_type_by_model_rd = 0;
   sf->disable_smooth_intra = 0;
   sf->perform_best_rd_based_gating_for_chroma = 0;
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index 0cf9d3d..f4ea4f6 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -673,6 +673,10 @@
   // of quantized coeffs
   int enable_winner_mode_for_coeff_opt;
 
+  // Flag used to control the winner mode processing for transform size
+  // search method
+  int enable_winner_mode_for_tx_size_srch;
+
   // Flag used to control the speed of the eob selection in trellis.
   int trellis_eob_fast;