diff --git a/crates/autopilot/src/boundary/order.rs b/crates/autopilot/src/boundary/order.rs
index d7d40d26fc..46c710875d 100644
--- a/crates/autopilot/src/boundary/order.rs
+++ b/crates/autopilot/src/boundary/order.rs
@@ -13,7 +13,6 @@ pub fn to_domain(
         buy_token: order.data.buy_token,
         sell_amount: order.data.sell_amount,
         buy_amount: order.data.buy_amount,
-        solver_fee: order.metadata.full_fee_amount,
         user_fee: order.data.fee_amount,
         protocol_fees,
         valid_to: order.data.valid_to,
diff --git a/crates/autopilot/src/domain/auction/order.rs b/crates/autopilot/src/domain/auction/order.rs
index a06ad6b7e6..b974f9848e 100644
--- a/crates/autopilot/src/domain/auction/order.rs
+++ b/crates/autopilot/src/domain/auction/order.rs
@@ -10,7 +10,6 @@ pub struct Order {
     pub buy_token: H160,
     pub sell_amount: U256,
     pub buy_amount: U256,
-    pub solver_fee: U256,
     pub user_fee: U256,
     pub protocol_fees: Vec<fee::Policy>,
     pub kind: Kind,
diff --git a/crates/autopilot/src/infra/persistence/dto/order.rs b/crates/autopilot/src/infra/persistence/dto/order.rs
index 3e2edfe1e6..bbb3a9efbe 100644
--- a/crates/autopilot/src/infra/persistence/dto/order.rs
+++ b/crates/autopilot/src/infra/persistence/dto/order.rs
@@ -21,8 +21,6 @@ pub struct Order {
     #[serde_as(as = "HexOrDecimalU256")]
     pub buy_amount: U256,
     #[serde_as(as = "HexOrDecimalU256")]
-    pub solver_fee: U256,
-    #[serde_as(as = "HexOrDecimalU256")]
     pub user_fee: U256,
     pub protocol_fees: Vec<FeePolicy>,
     pub valid_to: u32,
@@ -50,7 +48,6 @@ pub fn from_domain(order: domain::Order) -> Order {
         buy_token: order.buy_token,
         sell_amount: order.sell_amount,
         buy_amount: order.buy_amount,
-        solver_fee: order.solver_fee,
         user_fee: order.user_fee,
         protocol_fees: order.protocol_fees.into_iter().map(Into::into).collect(),
         valid_to: order.valid_to,
@@ -80,7 +77,6 @@ pub fn to_domain(order: Order) -> domain::Order {
         buy_token: order.buy_token,
         sell_amount: order.sell_amount,
         buy_amount: order.buy_amount,
-        solver_fee: order.solver_fee,
         user_fee: order.user_fee,
         protocol_fees: order.protocol_fees.into_iter().map(Into::into).collect(),
         valid_to: order.valid_to,
diff --git a/crates/driver/openapi.yml b/crates/driver/openapi.yml
index 7f644db14f..53ce926de3 100644
--- a/crates/driver/openapi.yml
+++ b/crates/driver/openapi.yml
@@ -197,12 +197,6 @@ components:
         buyAmount:
           description: Amount to be bought
           $ref: "#/components/schemas/TokenAmount"
-        solverFee:
-          description: |
-            The fee that the solver should use to compute the objective value of the solution.
-
-            This fee may be different from user fee as it removes any subsidies.
-          $ref: "#/components/schemas/TokenAmount"
         userFee:
           description: |
             The fee that the user signed to pay for getting their order included.
diff --git a/crates/driver/src/boundary/settlement.rs b/crates/driver/src/boundary/settlement.rs
index cf1e177bb2..d5d9357547 100644
--- a/crates/driver/src/boundary/settlement.rs
+++ b/crates/driver/src/boundary/settlement.rs
@@ -99,7 +99,7 @@ impl Settlement {
                         to_boundary_order(trade.order()),
                         LimitOrderExecution {
                             filled: trade.executed().into(),
-                            scoring_fee: trade.scoring_fee().into(),
+                            fee: trade.fee().into(),
                         },
                     )
                 }
@@ -107,7 +107,7 @@ impl Settlement {
                     to_boundary_jit_order(&DomainSeparator(domain.0), trade.order()),
                     LimitOrderExecution {
                         filled: trade.executed().into(),
-                        scoring_fee: 0.into(),
+                        fee: 0.into(),
                     },
                 ),
             };
@@ -234,8 +234,8 @@ impl Settlement {
         )?;
 
         let surplus = self.inner.total_surplus(&prices);
-        let solver_fees = self.inner.total_scoring_fees(&prices);
-        let quality = surplus + solver_fees;
+        let scoring_fees = self.inner.total_scoring_fees(&prices);
+        let quality = surplus + scoring_fees;
 
         Ok(eth::U256::from_big_rational(&quality)?.into())
     }
@@ -267,7 +267,7 @@ fn to_boundary_order(order: &competition::Order) -> Order {
             buy_token: order.buy.token.into(),
             sell_amount: order.sell.amount.into(),
             buy_amount: order.buy.amount.into(),
-            fee_amount: order.fee.user.into(),
+            fee_amount: order.user_fee.into(),
             receiver: order.receiver.map(Into::into),
             valid_to: order.valid_to.into(),
             app_data: AppDataHash(order.app_data.into()),
@@ -288,7 +288,7 @@ fn to_boundary_order(order: &competition::Order) -> Order {
         },
         metadata: OrderMetadata {
             full_fee_amount: Default::default(),
-            solver_fee: order.fee.solver.into(),
+            solver_fee: order.user_fee.into(),
             class: match order.kind {
                 competition::order::Kind::Market => OrderClass::Market,
                 competition::order::Kind::Liquidity => OrderClass::Liquidity,
diff --git a/crates/driver/src/domain/competition/auction.rs b/crates/driver/src/domain/competition/auction.rs
index 66cf59cd7e..f7a432cd25 100644
--- a/crates/driver/src/domain/competition/auction.rs
+++ b/crates/driver/src/domain/competition/auction.rs
@@ -235,7 +235,7 @@ impl AuctionProcessor {
 
             let max_sell = match {
                 let available = order.available(weth);
-                available.sell.amount.0.checked_add(available.fee.user.0)
+                available.sell.amount.0.checked_add(available.user_fee.0)
             } {
                 Some(amount) => order::SellAmount(amount),
                 None => {
diff --git a/crates/driver/src/domain/competition/order/mod.rs b/crates/driver/src/domain/competition/order/mod.rs
index 96be3492ec..8789a960cf 100644
--- a/crates/driver/src/domain/competition/order/mod.rs
+++ b/crates/driver/src/domain/competition/order/mod.rs
@@ -25,7 +25,7 @@ pub struct Order {
     /// The maximum amount this order is allowed to sell when completely filled.
     pub sell: eth::Asset,
     pub side: Side,
-    pub fee: Fee,
+    pub user_fee: SellAmount,
     pub kind: Kind,
     pub app_data: AppData,
     pub partial: Partial,
@@ -97,16 +97,6 @@ impl From<TargetAmount> for eth::TokenAmount {
     }
 }
 
-/// Order fee denominated in the sell token.
-#[derive(Debug, Default, Clone, Copy)]
-pub struct Fee {
-    /// The order fee that is actually paid by the user.
-    pub user: SellAmount,
-    /// The fee used for scoring. This is a scaled version of the user fee to
-    /// incentivize solvers to solve orders in batches.
-    pub solver: SellAmount,
-}
-
 /// The available amounts for a specific order that gets passed to the solver.
 ///
 /// These amounts differ from the order buy/sell/fee amounts in two ways:
@@ -129,7 +119,7 @@ pub struct Available {
     /// solver engine.
     pub buy: eth::Asset,
     /// The available fee amount.
-    pub fee: Fee,
+    pub user_fee: SellAmount,
 }
 
 impl Order {
@@ -182,7 +172,7 @@ impl Order {
                 token: self.buy.token.wrap(weth),
                 amount: self.buy.amount,
             },
-            fee: self.fee,
+            user_fee: self.user_fee,
         };
 
         let available = match self.partial {
@@ -191,11 +181,7 @@ impl Order {
         };
         let target = self.target();
 
-        for amount in [
-            &mut amounts.sell.amount.0,
-            &mut amounts.fee.user.0,
-            &mut amounts.fee.solver.0,
-        ] {
+        for amount in [&mut amounts.sell.amount.0, &mut amounts.user_fee.0] {
             *amount = util::math::mul_ratio(*amount, available.0, target.0).unwrap_or_default();
         }
 
@@ -441,7 +427,7 @@ mod tests {
                 Some(executed) if executed.token == buy(0).token => Side::Buy,
                 _ => panic!(),
             },
-            fee: Default::default(),
+            user_fee: Default::default(),
             kind: Kind::Limit,
             app_data: Default::default(),
             partial: available
diff --git a/crates/driver/src/domain/competition/solution/trade.rs b/crates/driver/src/domain/competition/solution/trade.rs
index 6fd642430a..c09e977fb1 100644
--- a/crates/driver/src/domain/competition/solution/trade.rs
+++ b/crates/driver/src/domain/competition/solution/trade.rs
@@ -77,20 +77,11 @@ impl Fulfillment {
         self.executed
     }
 
-    /// Returns the fee that should be considered as collected when
-    /// scoring a solution.
-    pub fn scoring_fee(&self) -> order::SellAmount {
-        match self.fee {
-            Fee::Static => self.order.fee.solver,
-            Fee::Dynamic(fee) => fee,
-        }
-    }
-
     /// Returns the effectively paid fee from the user's perspective
     /// considering their signed order and the uniform clearing prices
     pub fn fee(&self) -> order::SellAmount {
         match self.fee {
-            Fee::Static => self.order.fee.user,
+            Fee::Static => self.order.user_fee,
             Fee::Dynamic(fee) => fee,
         }
     }
diff --git a/crates/driver/src/domain/quote.rs b/crates/driver/src/domain/quote.rs
index d99bca6cbd..fca25d302f 100644
--- a/crates/driver/src/domain/quote.rs
+++ b/crates/driver/src/domain/quote.rs
@@ -118,7 +118,7 @@ impl Order {
                 buy: self.buy(),
                 sell: self.sell(),
                 side: self.side,
-                fee: Default::default(),
+                user_fee: Default::default(),
                 kind: competition::order::Kind::Market,
                 app_data: Default::default(),
                 partial: competition::order::Partial::No,
diff --git a/crates/driver/src/infra/api/routes/solve/dto/auction.rs b/crates/driver/src/infra/api/routes/solve/dto/auction.rs
index d131b9813a..c863e01c04 100644
--- a/crates/driver/src/infra/api/routes/solve/dto/auction.rs
+++ b/crates/driver/src/infra/api/routes/solve/dto/auction.rs
@@ -46,10 +46,7 @@ impl Auction {
                         Kind::Sell => competition::order::Side::Sell,
                         Kind::Buy => competition::order::Side::Buy,
                     },
-                    fee: competition::order::Fee {
-                        user: order.user_fee.into(),
-                        solver: order.solver_fee.into(),
-                    },
+                    user_fee: order.user_fee.into(),
                     kind: match order.class {
                         Class::Market => competition::order::Kind::Market,
                         Class::Limit => competition::order::Kind::Limit,
@@ -227,8 +224,6 @@ struct Order {
     #[serde_as(as = "serialize::U256")]
     buy_amount: eth::U256,
     #[serde_as(as = "serialize::U256")]
-    solver_fee: eth::U256,
-    #[serde_as(as = "serialize::U256")]
     user_fee: eth::U256,
     protocol_fees: Vec<FeePolicy>,
     valid_to: u32,
diff --git a/crates/driver/src/infra/solver/dto/auction.rs b/crates/driver/src/infra/solver/dto/auction.rs
index 91307f57a6..a89491d75a 100644
--- a/crates/driver/src/infra/solver/dto/auction.rs
+++ b/crates/driver/src/infra/solver/dto/auction.rs
@@ -66,7 +66,7 @@ impl Auction {
                         buy_token: available.buy.token.into(),
                         sell_amount: available.sell.amount.into(),
                         buy_amount: available.buy.amount.into(),
-                        fee_amount: available.fee.solver.into(),
+                        fee_amount: available.user_fee.into(),
                         kind: match order.side {
                             competition::order::Side::Buy => Kind::Buy,
                             competition::order::Side::Sell => Kind::Sell,
diff --git a/crates/driver/src/tests/setup/driver.rs b/crates/driver/src/tests/setup/driver.rs
index cd6d1dafe0..13c480d03c 100644
--- a/crates/driver/src/tests/setup/driver.rs
+++ b/crates/driver/src/tests/setup/driver.rs
@@ -71,7 +71,6 @@ pub fn solve_req(test: &Test) -> serde_json::Value {
             "buyToken": hex_address(test.blockchain.get_token(quote.order.buy_token)),
             "sellAmount": quote.sell_amount().to_string(),
             "buyAmount": quote.buy_amount().to_string(),
-            "solverFee": quote.order.user_fee.to_string(),
             "userFee": quote.order.user_fee.to_string(),
             "protocolFees": match quote.order.kind {
                 order::Kind::Market => json!([]),
diff --git a/crates/e2e/tests/e2e/partially_fillable_balance.rs b/crates/e2e/tests/e2e/partially_fillable_balance.rs
index 0b0a061ceb..fd5c2a15a0 100644
--- a/crates/e2e/tests/e2e/partially_fillable_balance.rs
+++ b/crates/e2e/tests/e2e/partially_fillable_balance.rs
@@ -97,7 +97,7 @@ async fn test(web3: Web3) {
     let order = auction.orders.into_iter().next().unwrap();
     assert!(order.partially_fillable);
     assert!(matches!(order.class, OrderClass::Limit));
-    assert_eq!(order.solver_fee, 0.into());
+    assert_eq!(order.user_fee, 0.into());
 
     tracing::info!("Waiting for trade.");
     let trade_happened =
diff --git a/crates/e2e/tests/e2e/partially_fillable_pool.rs b/crates/e2e/tests/e2e/partially_fillable_pool.rs
index ad443eaf5a..ccc78a87d6 100644
--- a/crates/e2e/tests/e2e/partially_fillable_pool.rs
+++ b/crates/e2e/tests/e2e/partially_fillable_pool.rs
@@ -97,7 +97,7 @@ async fn test(web3: Web3) {
     let order = auction.orders.into_iter().next().unwrap();
     assert!(order.partially_fillable);
     assert!(matches!(order.class, OrderClass::Limit));
-    assert_eq!(order.solver_fee, 0.into());
+    assert_eq!(order.user_fee, 0.into());
 
     tracing::info!("Waiting for trade.");
     let trade_happened =
diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs
index b404cf2373..ac9ba2c44c 100644
--- a/crates/model/src/order.rs
+++ b/crates/model/src/order.rs
@@ -758,6 +758,8 @@ pub struct OrderMetadata {
     /// execution we could find while quoting converted to an equivalent
     /// `sell_token` amount.
     /// Does not take partial fill into account.
+    ///
+    /// [TO BE DEPRECATED]
     #[serde_as(as = "HexOrDecimalU256")]
     pub full_fee_amount: U256,
     /// The fee amount that should be used for objective value computations.
@@ -767,6 +769,8 @@ pub struct OrderMetadata {
     /// factor to make matching orders more valuable from an objective value
     /// perspective.
     /// Does not take partial fill into account.
+    ///
+    /// [TO BE DEPRECATED]
     #[serde_as(as = "HexOrDecimalU256")]
     pub solver_fee: U256,
     #[serde(default, skip_serializing_if = "Option::is_none")]
diff --git a/crates/orderbook/openapi.yml b/crates/orderbook/openapi.yml
index 9e928ecb66..912de5695b 100644
--- a/crates/orderbook/openapi.yml
+++ b/crates/orderbook/openapi.yml
@@ -928,10 +928,6 @@ components:
           description: see `OrderParameters::feeAmount`
           allOf:
             - $ref: "#/components/schemas/TokenAmount"
-        solverFee:
-          description: Amount that the signed fee would be without subsidies.
-          allOf:
-            - $ref: "#/components/schemas/TokenAmount"
         validTo:
           description: see `OrderParameters::validTo`
           type: integer
@@ -995,7 +991,6 @@ components:
         - sellAmount
         - buyAmount
         - userFee
-        - solverFee
         - validTo
         - kind
         - receiver
diff --git a/crates/orderbook/src/dto/order.rs b/crates/orderbook/src/dto/order.rs
index 76fcce13ee..a50704125e 100644
--- a/crates/orderbook/src/dto/order.rs
+++ b/crates/orderbook/src/dto/order.rs
@@ -23,8 +23,6 @@ pub struct Order {
     #[serde_as(as = "HexOrDecimalU256")]
     pub buy_amount: U256,
     #[serde_as(as = "HexOrDecimalU256")]
-    pub solver_fee: U256,
-    #[serde_as(as = "HexOrDecimalU256")]
     pub user_fee: U256,
     pub protocol_fees: Vec<FeePolicy>,
     pub valid_to: u32,
diff --git a/crates/shared/src/http_solver/model.rs b/crates/shared/src/http_solver/model.rs
index 4b9874cf8d..de59281fd6 100644
--- a/crates/shared/src/http_solver/model.rs
+++ b/crates/shared/src/http_solver/model.rs
@@ -42,6 +42,7 @@ pub struct OrderModel {
     pub buy_amount: U256,
     pub allow_partial_fill: bool,
     pub is_sell_order: bool,
+    /// Represents user_fee. Which is 0 for limit orders.
     pub fee: TokenAmount,
     pub cost: TokenAmount,
     pub is_liquidity_order: bool,
diff --git a/crates/solver/src/liquidity.rs b/crates/solver/src/liquidity.rs
index 817dd1ce5a..8a15a7ffb6 100644
--- a/crates/solver/src/liquidity.rs
+++ b/crates/solver/src/liquidity.rs
@@ -184,9 +184,8 @@ pub struct LimitOrder {
     pub buy_amount: U256,
     pub kind: OrderKind,
     pub partially_fillable: bool,
-    /// The fee that should be used for objective value computations.
     /// Takes partiall fill into account.
-    pub scoring_fee: U256,
+    pub user_fee: U256,
     #[cfg_attr(test, derivative(PartialEq = "ignore"))]
     pub settlement_handling: Arc<dyn SettlementHandling<Self>>,
     pub exchange: Exchange,
@@ -223,20 +222,16 @@ pub struct LimitOrderExecution {
     /// The amount that the order `side` (`buy`, `sell`) should be filled by
     /// this trade.
     pub filled: U256,
-    /// The fee (for the objective value) associated with this order.
     /// For limit orders this value gets computed by the
     /// solver already refers to the `filled` amount. In this case no
     /// further scaling is necessary for partial fills. For market orders
-    /// this is unsubsidized fee amount.
-    pub scoring_fee: U256,
+    /// this is signed user fee amount.
+    pub fee: U256,
 }
 
 impl LimitOrderExecution {
-    pub fn new(filled: U256, scoring_fee: U256) -> Self {
-        Self {
-            filled,
-            scoring_fee,
-        }
+    pub fn new(filled: U256, fee: U256) -> Self {
+        Self { filled, fee }
     }
 }
 
@@ -267,7 +262,7 @@ impl Default for LimitOrder {
             buy_amount: Default::default(),
             kind: Default::default(),
             partially_fillable: Default::default(),
-            scoring_fee: Default::default(),
+            user_fee: Default::default(),
             settlement_handling: tests::CapturingSettlementHandler::arc(),
             id: Default::default(),
             exchange: Exchange::GnosisProtocol,
diff --git a/crates/solver/src/liquidity/order_converter.rs b/crates/solver/src/liquidity/order_converter.rs
index e064ccc023..ca48747a12 100644
--- a/crates/solver/src/liquidity/order_converter.rs
+++ b/crates/solver/src/liquidity/order_converter.rs
@@ -63,13 +63,6 @@ impl OrderConverter {
             }
             OrderClass::Limit => LimitOrderId::Limit(order.metadata.uid),
         };
-
-        // The reported fee amount that is used for objective computation is the
-        // order's full full amount scaled by a constant factor.
-        let scoring_fee = match order.solver_determines_fee() {
-            true => 0.into(),
-            false => remaining.remaining(order.metadata.solver_fee)?,
-        };
         let sell_amount = remaining.remaining(sell_amount)?;
         let buy_amount = remaining.remaining(order.data.buy_amount)?;
         ensure!(
@@ -85,7 +78,7 @@ impl OrderConverter {
             buy_amount,
             kind: order.data.kind,
             partially_fillable: order.data.partially_fillable,
-            scoring_fee,
+            user_fee: remaining.remaining(order.data.fee_amount)?,
             settlement_handling: Arc::new(OrderSettlementHandler {
                 order,
                 native_token: self.native_token.clone(),
@@ -115,8 +108,7 @@ impl SettlementHandling<LimitOrder> for OrderSettlementHandler {
             encoder.add_token_equivalency(self.native_token.address(), BUY_ETH_ADDRESS)?;
         }
 
-        let trade =
-            encoder.add_trade(self.order.clone(), execution.filled, execution.scoring_fee)?;
+        let trade = encoder.add_trade(self.order.clone(), execution.filled, execution.fee)?;
 
         if is_native_token_buy_order {
             encoder.add_unwrap(UnwrapWethInteraction {
@@ -195,7 +187,7 @@ pub mod tests {
 
         let execution = LimitOrderExecution::new(1337.into(), 0.into());
         let executed_buy_amount = U256::from(2 * 1337);
-        let scoring_fee = U256::from(1234);
+        let fee = U256::from(1234);
 
         let prices = hashmap! {
             native_token.address() => U256::from(100),
@@ -230,9 +222,7 @@ pub mod tests {
                     weth: native_token,
                     amount: executed_buy_amount,
                 });
-                assert!(encoder
-                    .add_trade(order, execution.filled, scoring_fee)
-                    .is_ok());
+                assert!(encoder.add_trade(order, execution.filled, fee).is_ok());
             },
         );
     }
@@ -340,7 +330,7 @@ pub mod tests {
             },
             metadata: OrderMetadata {
                 executed_sell_amount_before_fees: 10.into(),
-                solver_fee: 200.into(),
+                solver_fee: 60.into(),
                 ..Default::default()
             },
             ..Default::default()
@@ -355,7 +345,7 @@ pub mod tests {
         // Amounts are halved because the order is half executed.
         assert_eq!(order_.sell_amount, 10.into());
         assert_eq!(order_.buy_amount, 20.into());
-        assert_eq!(order_.scoring_fee, 100.into());
+        assert_eq!(order_.user_fee, 30.into());
 
         let order_ = converter
             .normalize_limit_order(BalancedOrder {
@@ -366,7 +356,7 @@ pub mod tests {
         // Amounts are quartered because of balance.
         assert_eq!(order_.sell_amount, 5.into());
         assert_eq!(order_.buy_amount, 10.into());
-        assert_eq!(order_.scoring_fee, 50.into());
+        assert_eq!(order_.user_fee, 15.into());
 
         order.metadata.executed_sell_amount_before_fees = 0.into();
         let order_ = converter
@@ -378,7 +368,7 @@ pub mod tests {
         // Amounts are still quartered because of balance.
         assert_eq!(order_.sell_amount, 5.into());
         assert_eq!(order_.buy_amount, 10.into());
-        assert_eq!(order_.scoring_fee, 50.into());
+        assert_eq!(order_.user_fee, 15.into());
     }
 
     #[test]
diff --git a/crates/solver/src/liquidity/zeroex.rs b/crates/solver/src/liquidity/zeroex.rs
index 233b03789d..c50fdfa10c 100644
--- a/crates/solver/src/liquidity/zeroex.rs
+++ b/crates/solver/src/liquidity/zeroex.rs
@@ -67,7 +67,7 @@ impl ZeroExLiquidity {
             buy_amount: record.metadata.remaining_fillable_taker_amount.into(),
             kind: OrderKind::Buy,
             partially_fillable: true,
-            scoring_fee: U256::zero(),
+            user_fee: U256::zero(),
             settlement_handling: Arc::new(OrderSettlementHandler {
                 order: record.order,
                 zeroex: self.zeroex.clone(),
diff --git a/crates/solver/src/settlement.rs b/crates/solver/src/settlement.rs
index c354111f97..3df284f283 100644
--- a/crates/solver/src/settlement.rs
+++ b/crates/solver/src/settlement.rs
@@ -23,15 +23,14 @@ pub use self::settlement_encoder::{verify_executed_amount, PricedTrade, Settleme
 pub struct Trade {
     pub order: Order,
     pub executed_amount: U256,
-    /// The fee amount used for objective value computations.
-    pub scoring_fee: U256,
+    pub fee: U256,
 }
 
 impl Trade {
     /// Returns the fee taken from the surplus.
     pub fn surplus_fee(&self) -> Option<U256> {
         match self.order.solver_determines_fee() {
-            true => Some(self.scoring_fee),
+            true => Some(self.fee),
             false => None,
         }
     }
@@ -151,8 +150,8 @@ impl Trade {
         let user_fee = self.order.data.fee_amount;
         match self.order.solver_determines_fee() {
             true => {
-                // Solvers already scale the `scoring_fee` for these orders.
-                self.scale_amount(user_fee)?.checked_add(self.scoring_fee)
+                // Solvers already scale the `fee` for these orders.
+                self.scale_amount(user_fee)?.checked_add(self.fee)
             }
             false => self.scale_amount(user_fee),
         }
@@ -436,10 +435,8 @@ impl Settlement {
     pub fn total_scoring_fees(&self, external_prices: &ExternalPrices) -> BigRational {
         self.user_trades()
             .filter_map(|trade| {
-                external_prices.try_get_native_amount(
-                    trade.order.data.sell_token,
-                    trade.scoring_fee.to_big_rational(),
-                )
+                external_prices
+                    .try_get_native_amount(trade.order.data.sell_token, trade.fee.to_big_rational())
             })
             .sum()
     }
@@ -1326,7 +1323,7 @@ pub mod tests {
             // Note that the scaled fee amount is different than the order's
             // signed fee amount. This happens for subsidized orders, and when
             // a fee objective scaling factor is configured.
-            scoring_fee: 5.into(),
+            fee: 5.into(),
         };
         let trade1 = Trade {
             order: Order {
@@ -1340,7 +1337,7 @@ pub mod tests {
                 ..Default::default()
             },
             executed_amount: 10.into(),
-            scoring_fee: 2.into(),
+            fee: 2.into(),
         };
 
         let clearing_prices = hashmap! {token0 => 5.into(), token1 => 10.into()};
@@ -1352,9 +1349,9 @@ pub mod tests {
 
         // Fee in sell tokens
         assert_eq!(trade0.executed_fee().unwrap(), 1.into());
-        assert_eq!(trade0.scoring_fee, 5.into());
+        assert_eq!(trade0.fee, 5.into());
         assert_eq!(trade1.executed_fee().unwrap(), 2.into());
-        assert_eq!(trade1.scoring_fee, 2.into());
+        assert_eq!(trade1.fee, 2.into());
 
         // Fee in wei of ETH
         let settlement = test_settlement(clearing_prices, vec![trade0, trade1]);
@@ -1386,7 +1383,7 @@ pub mod tests {
                     },
                     executed_amount: 1.into(),
                     // This is what matters for the objective value
-                    scoring_fee: 42.into(),
+                    fee: 42.into(),
                 },
                 Trade {
                     order: Order {
@@ -1406,7 +1403,7 @@ pub mod tests {
                     },
                     executed_amount: 1.into(),
                     // Doesn't count because it is a "liquidity order"
-                    scoring_fee: 1337.into(),
+                    fee: 1337.into(),
                 },
             ],
         );
@@ -1438,7 +1435,7 @@ pub mod tests {
                     ..Default::default()
                 },
                 executed_amount: 99760667014_u128.into(),
-                scoring_fee: 239332986_u128.into(),
+                fee: 239332986_u128.into(),
             }],
         );
 
@@ -1463,7 +1460,7 @@ pub mod tests {
                         ..Default::default()
                     },
                     executed_amount: 99760667014_u128.into(),
-                    scoring_fee: 239332986_u128.into(),
+                    fee: 239332986_u128.into(),
                 },
                 Trade {
                     order: Order {
@@ -1483,7 +1480,7 @@ pub mod tests {
                         ..Default::default()
                     },
                     executed_amount: 99760667014_u128.into(),
-                    scoring_fee: 77577144_u128.into(),
+                    fee: 77577144_u128.into(),
                 },
             ],
         );
@@ -1546,7 +1543,7 @@ pub mod tests {
                         ..Default::default()
                     },
                     executed_amount: 99_000_u128.into(),
-                    scoring_fee: 1_000_u128.into(),
+                    fee: 1_000_u128.into(),
                 }],
             );
 
@@ -1581,7 +1578,7 @@ pub mod tests {
                         OrderKind::Sell => 99_000_u128,
                     }
                     .into(),
-                    scoring_fee: 1_000_u128.into(),
+                    fee: 1_000_u128.into(),
                 }],
             );
 
@@ -1619,7 +1616,7 @@ pub mod tests {
                     ..Default::default()
                 },
                 executed_amount: 99_000_u128.into(),
-                scoring_fee: 1_000_u128.into(),
+                fee: 1_000_u128.into(),
             }],
         )
         .encode(InternalizationStrategy::SkipInternalizableInteraction);
diff --git a/crates/solver/src/settlement/settlement_encoder.rs b/crates/solver/src/settlement/settlement_encoder.rs
index bf974352cd..bb3f522b07 100644
--- a/crates/solver/src/settlement/settlement_encoder.rs
+++ b/crates/solver/src/settlement/settlement_encoder.rs
@@ -130,7 +130,7 @@ impl SettlementEncoder {
         let mut result = Self::new(clearing_prices);
         for trade in trades {
             result
-                .add_trade(trade.order, trade.executed_amount, trade.scoring_fee)
+                .add_trade(trade.order, trade.executed_amount, trade.fee)
                 .unwrap();
         }
         result
@@ -207,7 +207,7 @@ impl SettlementEncoder {
         &mut self,
         order: Order,
         executed_amount: U256,
-        scoring_fee: U256,
+        fee: U256,
     ) -> Result<TradeExecution> {
         verify_executed_amount(&order, executed_amount)?;
         let sell_price = self
@@ -230,7 +230,7 @@ impl SettlementEncoder {
             data: Trade {
                 order: order.clone(),
                 executed_amount,
-                scoring_fee,
+                fee,
             },
             tokens: TokenReference::Indexed {
                 sell_token_index,
@@ -252,23 +252,17 @@ impl SettlementEncoder {
         &mut self,
         order: Order,
         executed_amount: U256,
-        scoring_fee: U256,
+        fee: U256,
     ) -> Result<TradeExecution> {
         let interactions = order.interactions.clone();
         let execution = match &order.metadata.class {
-            OrderClass::Market => self.add_market_trade(order, executed_amount, scoring_fee)?,
+            OrderClass::Market => self.add_market_trade(order, executed_amount, fee)?,
             OrderClass::Liquidity => {
                 let (sell_price, buy_price) = (order.data.buy_amount, order.data.sell_amount);
-                self.add_custom_price_trade(
-                    order,
-                    executed_amount,
-                    scoring_fee,
-                    sell_price,
-                    buy_price,
-                )?
+                self.add_custom_price_trade(order, executed_amount, fee, sell_price, buy_price)?
             }
             OrderClass::Limit => {
-                let surplus_fee = scoring_fee;
+                let surplus_fee = fee;
 
                 // Solvers calculate with slightly adjusted amounts compared to
                 // the signed order, so adjust by the surplus fee (if needed) to
@@ -283,13 +277,7 @@ impl SettlementEncoder {
                 let (sell_price, buy_price) =
                     self.custom_price_for_limit_order(&order, executed_amount, surplus_fee)?;
 
-                self.add_custom_price_trade(
-                    order,
-                    executed_amount,
-                    scoring_fee,
-                    sell_price,
-                    buy_price,
-                )?
+                self.add_custom_price_trade(order, executed_amount, fee, sell_price, buy_price)?
             }
         };
         self.pre_interactions.extend(interactions.pre);
@@ -380,7 +368,7 @@ impl SettlementEncoder {
         &mut self,
         order: Order,
         executed_amount: U256,
-        scoring_fee: U256,
+        fee: U256,
         sell_price: U256,
         buy_price: U256,
     ) -> Result<TradeExecution> {
@@ -389,7 +377,7 @@ impl SettlementEncoder {
             data: Trade {
                 order,
                 executed_amount,
-                scoring_fee,
+                fee,
             },
             tokens: TokenReference::CustomPrice {
                 sell_token_price: sell_price,
@@ -1092,7 +1080,7 @@ pub mod tests {
                     data: Trade {
                         order: order13,
                         executed_amount: 11.into(),
-                        scoring_fee: 0.into()
+                        fee: 0.into()
                     },
                     tokens: TokenReference::Indexed {
                         sell_token_index: 0,
@@ -1103,7 +1091,7 @@ pub mod tests {
                     data: Trade {
                         order: order12,
                         executed_amount: 11.into(),
-                        scoring_fee: 0.into()
+                        fee: 0.into()
                     },
                     tokens: TokenReference::CustomPrice {
                         sell_token_price: 11.into(),
@@ -1114,7 +1102,7 @@ pub mod tests {
                     data: Trade {
                         order: order24,
                         executed_amount: 22.into(),
-                        scoring_fee: 0.into()
+                        fee: 0.into()
                     },
                     tokens: TokenReference::Indexed {
                         sell_token_index: 1,
@@ -1125,7 +1113,7 @@ pub mod tests {
                     data: Trade {
                         order: order23,
                         executed_amount: 11.into(),
-                        scoring_fee: 0.into()
+                        fee: 0.into()
                     },
                     tokens: TokenReference::CustomPrice {
                         sell_token_price: 11.into(),
@@ -1498,7 +1486,7 @@ pub mod tests {
                 data: Trade {
                     order,
                     executed_amount: 1_010_000_000_000_000_000u128.into(), // 1.01 WETH
-                    scoring_fee: U256::exp10(16)                           // 0.01 WETH (10 USDC)
+                    fee: U256::exp10(16)                                   // 0.01 WETH (10 USDC)
                 },
                 tokens: TokenReference::CustomPrice {
                     sell_token_price: U256::exp10(9),
@@ -1554,7 +1542,7 @@ pub mod tests {
                 data: Trade {
                     order,
                     executed_amount: U256::exp10(18), // 1 WETH
-                    scoring_fee: U256::exp10(7)       // 10 USDC
+                    fee: U256::exp10(7)               // 10 USDC
                 },
                 tokens: TokenReference::CustomPrice {
                     sell_token_price: U256::exp10(18),
diff --git a/crates/solver/src/solver/http_solver/instance_creation.rs b/crates/solver/src/solver/http_solver/instance_creation.rs
index 215228f419..a92d09cd83 100644
--- a/crates/solver/src/solver/http_solver/instance_creation.rs
+++ b/crates/solver/src/solver/http_solver/instance_creation.rs
@@ -262,7 +262,7 @@ fn order_models(
                     allow_partial_fill: order.partially_fillable,
                     is_sell_order: matches!(order.kind, OrderKind::Sell),
                     fee: TokenAmount {
-                        amount: order.scoring_fee,
+                        amount: order.user_fee,
                         token: order.sell_token,
                     },
                     cost,
diff --git a/crates/solver/src/solver/http_solver/settlement.rs b/crates/solver/src/solver/http_solver/settlement.rs
index 990704a78c..ced4aba4ec 100644
--- a/crates/solver/src/solver/http_solver/settlement.rs
+++ b/crates/solver/src/solver/http_solver/settlement.rs
@@ -89,7 +89,7 @@ impl Execution {
     ) -> Result<()> {
         match self {
             Execution::LimitOrder(order) => {
-                let scoring_fee = match order.order.solver_determines_fee() {
+                let fee = match order.order.solver_determines_fee() {
                     true => {
                         let fee = order.executed_fee_amount;
                         match enforce_correct_fees {
@@ -97,12 +97,12 @@ impl Execution {
                             false => fee.unwrap_or_default(),
                         }
                     }
-                    false => order.order.scoring_fee,
+                    false => order.order.user_fee,
                 };
 
                 let execution = LimitOrderExecution {
                     filled: order.executed_amount(),
-                    scoring_fee,
+                    fee,
                 };
 
                 settlement.with_liquidity(&order.order, execution)
@@ -739,7 +739,7 @@ mod tests {
                         ..Default::default()
                     },
                     executed_amount: 101.into(),
-                    scoring_fee: 0.into(),
+                    fee: 42.into(),
                 },
                 sell_token_price: 102.into(),
                 buy_token_price: 101.into(),
diff --git a/crates/solver/src/solver/naive_solver/multi_order_solver.rs b/crates/solver/src/solver/naive_solver/multi_order_solver.rs
index 7d820b3d61..dc0fba6243 100644
--- a/crates/solver/src/solver/naive_solver/multi_order_solver.rs
+++ b/crates/solver/src/solver/naive_solver/multi_order_solver.rs
@@ -117,7 +117,7 @@ fn solve_without_uniswap(
     for order in orders {
         let execution = LimitOrderExecution {
             filled: order.full_execution_amount(),
-            scoring_fee: order.scoring_fee,
+            fee: order.user_fee,
         };
         settlement.with_liquidity(order, execution)?;
     }
@@ -152,8 +152,8 @@ fn solve_with_uniswap(
     for order in orders {
         let execution = LimitOrderExecution {
             filled: order.full_execution_amount(),
-            // TODO: We still need to compute a `scoring_fee` for partially fillable limit orders.
-            scoring_fee: order.scoring_fee,
+            // TODO: We still need to compute a fee for partially fillable limit orders.
+            fee: order.user_fee,
         };
         settlement.with_liquidity(order, execution).ok()?;
     }
@@ -829,7 +829,7 @@ mod tests {
                 let limit_order = LimitOrder::from(order);
                 let execution = LimitOrderExecution::new(
                     limit_order.full_execution_amount(),
-                    limit_order.scoring_fee,
+                    limit_order.user_fee,
                 );
                 settlement.with_liquidity(&limit_order, execution).unwrap();
             }
diff --git a/crates/solver/src/solver/single_order_solver.rs b/crates/solver/src/solver/single_order_solver.rs
index cf004b3fcc..4b713a7ca0 100644
--- a/crates/solver/src/solver/single_order_solver.rs
+++ b/crates/solver/src/solver/single_order_solver.rs
@@ -495,8 +495,8 @@ impl SingleOrderSettlement {
         };
 
         // Compute the surplus fee that needs to be incorporated into the prices
-        // and solver fee which will be used for scoring.
-        let (surplus_fee, scoring_fee) = if order.solver_determines_fee() {
+        // and fee which will be used for execution.
+        let (surplus_fee, fee) = if order.solver_determines_fee() {
             let fee = number::conversions::big_rational_to_u256(
                 &prices
                     .try_get_token_amount(
@@ -509,7 +509,7 @@ impl SingleOrderSettlement {
 
             (fee, fee)
         } else {
-            (U256::zero(), order.scoring_fee)
+            (U256::zero(), order.user_fee)
         };
 
         // Compute the actual executed amounts accounting for surplus fees.
@@ -572,7 +572,7 @@ impl SingleOrderSettlement {
                 OrderKind::Buy => executed_buy_amount,
                 OrderKind::Sell => executed_sell_amount - surplus_fee,
             },
-            scoring_fee,
+            fee,
         };
         settlement.with_liquidity(order, execution)?;
         for interaction in &self.interactions {
diff --git a/crates/solvers/src/boundary/naive.rs b/crates/solvers/src/boundary/naive.rs
index 45905b81d4..3e47ef1ac0 100644
--- a/crates/solvers/src/boundary/naive.rs
+++ b/crates/solvers/src/boundary/naive.rs
@@ -70,7 +70,7 @@ pub fn solve(
                 order::Side::Sell => OrderKind::Sell,
             },
             partially_fillable: order.partially_fillable,
-            scoring_fee: order.fee().amount,
+            user_fee: order.fee().amount,
             settlement_handling: Arc::new(OrderHandler {
                 order: Order {
                     metadata: OrderMetadata {
@@ -213,7 +213,7 @@ impl SettlementHandling<LimitOrder> for OrderHandler {
         execution: LimitOrderExecution,
         encoder: &mut SettlementEncoder,
     ) -> anyhow::Result<()> {
-        encoder.add_trade(self.order.clone(), execution.filled, execution.scoring_fee)?;
+        encoder.add_trade(self.order.clone(), execution.filled, execution.fee)?;
         Ok(())
     }
 }
diff --git a/database/README.md b/database/README.md
index f92a9f811e..d63cfaca15 100644
--- a/database/README.md
+++ b/database/README.md
@@ -327,7 +327,7 @@ During the solver competition solvers promise a solution of a certain quality. I
  gas\_used             | numeric | not null | amount of gas the settlement consumed
  effective\_gas\_price | numeric | not null | effective gas price (basically the [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) gas price reduced to a single value)
  surplus               | numeric | not null | amount of tokens users received more than their limit price converted to ETH
- fee                   | numeric | not null | total amount of `solver_fee` collected in the auction (see order\_execution.solver\_fee)
+ fee                   | numeric | not null | total amount of fees collected in the auction
 
 Indexes:
 - PRIMARY KEY: btree(`block_number`, `log_index`)