diff --git a/core/src/main/java/google/registry/tools/RenewDomainCommand.java b/core/src/main/java/google/registry/tools/RenewDomainCommand.java
index 0ddcc9f61..7f820d210 100644
--- a/core/src/main/java/google/registry/tools/RenewDomainCommand.java
+++ b/core/src/main/java/google/registry/tools/RenewDomainCommand.java
@@ -15,6 +15,7 @@
 package google.registry.tools;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Strings.isNullOrEmpty;
 import static google.registry.model.EppResourceUtils.loadByForeignKey;
 import static google.registry.util.CollectionUtils.findDuplicates;
 import static google.registry.util.PreconditionsUtils.checkArgumentPresent;
@@ -37,6 +38,13 @@ import org.joda.time.format.DateTimeFormatter;
 @Parameters(separators = " =", commandDescription = "Renew domain(s) via EPP.")
 final class RenewDomainCommand extends MutatingEppToolCommand {
 
+  @Parameter(
+      names = {"-c", "--client"},
+      description =
+          "The registrar to execute as and bill the renewal to; otherwise each domain's sponsoring"
+              + " registrar. Renewals by non-sponsoring registrars require --superuser as well.")
+  String clientId;
+
   @Parameter(
       names = {"-p", "--period"},
       description = "Number of years to renew the registration for (defaults to 1).")
@@ -63,7 +71,7 @@ final class RenewDomainCommand extends MutatingEppToolCommand {
       setSoyTemplate(RenewDomainSoyInfo.getInstance(), RenewDomainSoyInfo.RENEWDOMAIN);
       DomainBase domain = domainOptional.get();
       addSoyRecord(
-          domain.getCurrentSponsorClientId(),
+          isNullOrEmpty(clientId) ? domain.getCurrentSponsorClientId() : clientId,
           new SoyMapData(
               "domainName", domain.getFullyQualifiedDomainName(),
               "expirationDate", domain.getRegistrationExpirationTime().toString(DATE_FORMATTER),
diff --git a/core/src/test/java/google/registry/flows/domain/DomainRenewFlowTest.java b/core/src/test/java/google/registry/flows/domain/DomainRenewFlowTest.java
index df047deaa..aeba114da 100644
--- a/core/src/test/java/google/registry/flows/domain/DomainRenewFlowTest.java
+++ b/core/src/test/java/google/registry/flows/domain/DomainRenewFlowTest.java
@@ -153,6 +153,8 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
     doSuccessfulTest(
         responseFilename,
         renewalYears,
+        "TheRegistrar",
+        UserPrivileges.NORMAL,
         substitutions,
         Money.of(USD, 11).multipliedBy(renewalYears));
   }
@@ -160,13 +162,16 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
   private void doSuccessfulTest(
       String responseFilename,
       int renewalYears,
+      String renewalClientId,
+      UserPrivileges userPrivileges,
       Map<String, String> substitutions,
       Money totalRenewCost)
       throws Exception {
     assertTransactionalFlow(true);
     DateTime currentExpiration = reloadResourceByForeignKey().getRegistrationExpirationTime();
     DateTime newExpiration = currentExpiration.plusYears(renewalYears);
-    runFlowAssertResponse(loadFile(responseFilename, substitutions));
+    runFlowAssertResponse(
+        CommitMode.LIVE, userPrivileges, loadFile(responseFilename, substitutions));
     DomainBase domain = reloadResourceByForeignKey();
     HistoryEntry historyEntryDomainRenew =
         getOnlyHistoryEntryOfType(domain, HistoryEntry.Type.DOMAIN_RENEW);
@@ -183,13 +188,13 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
         .and()
         .hasLastEppUpdateTime(clock.nowUtc())
         .and()
-        .hasLastEppUpdateClientId("TheRegistrar");
+        .hasLastEppUpdateClientId(renewalClientId);
     assertAboutHistoryEntries().that(historyEntryDomainRenew).hasPeriodYears(renewalYears);
     BillingEvent.OneTime renewBillingEvent =
         new BillingEvent.OneTime.Builder()
             .setReason(Reason.RENEW)
             .setTargetId(getUniqueIdFromCommand())
-            .setClientId("TheRegistrar")
+            .setClientId(renewalClientId)
             .setCost(totalRenewCost)
             .setPeriodYears(renewalYears)
             .setEventTime(clock.nowUtc())
@@ -233,7 +238,7 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             GracePeriod.create(
                 GracePeriodStatus.RENEW,
                 clock.nowUtc().plus(Registry.get("tld").getRenewGracePeriodLength()),
-                "TheRegistrar",
+                renewalClientId,
                 null),
             renewBillingEvent));
   }
@@ -256,6 +261,19 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
         ImmutableMap.of("DOMAIN", "example.tld", "EXDATE", "2005-04-03T22:00:00.0Z"));
   }
 
+  @Test
+  public void testSuccess_recurringClientIdIsSame_whenSuperuserOverridesRenewal() throws Exception {
+    persistDomain();
+    setClientIdForFlow("NewRegistrar");
+    doSuccessfulTest(
+        "domain_renew_response.xml",
+        5,
+        "NewRegistrar",
+        UserPrivileges.SUPERUSER,
+        ImmutableMap.of("DOMAIN", "example.tld", "EXDATE", "2005-04-03T22:00:00.0Z"),
+        Money.of(USD, 55));
+  }
+
   @Test
   public void testSuccess_customLogicFee() throws Exception {
     // The "costly-renew" domain has an additional RENEW fee of 100 from custom logic on top of the
@@ -269,7 +287,13 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
             "FEE", "111.00");
     setEppInput("domain_renew_fee.xml", customFeeMap);
     persistDomain();
-    doSuccessfulTest("domain_renew_response_fee.xml", 1, customFeeMap, Money.of(USD, 111));
+    doSuccessfulTest(
+        "domain_renew_response_fee.xml",
+        1,
+        "TheRegistrar",
+        UserPrivileges.NORMAL,
+        customFeeMap,
+        Money.of(USD, 111));
   }
 
   @Test
@@ -687,7 +711,7 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
 
   @Test
   public void testFailure_unauthorizedClient() throws Exception {
-    sessionMetadata.setClientId("NewRegistrar");
+    setClientIdForFlow("NewRegistrar");
     persistActiveDomain(getUniqueIdFromCommand());
     EppException thrown = assertThrows(ResourceNotOwnedException.class, this::runFlow);
     assertAboutEppExceptions().that(thrown).marshalsToXml();
@@ -695,7 +719,7 @@ public class DomainRenewFlowTest extends ResourceFlowTestCase<DomainRenewFlow, D
 
   @Test
   public void testSuccess_superuserUnauthorizedClient() throws Exception {
-    sessionMetadata.setClientId("NewRegistrar");
+    setClientIdForFlow("NewRegistrar");
     persistDomain();
     runFlowAssertResponse(
         CommitMode.LIVE,
diff --git a/core/src/test/java/google/registry/tools/RenewDomainCommandTest.java b/core/src/test/java/google/registry/tools/RenewDomainCommandTest.java
index 225aaf88c..261597e37 100644
--- a/core/src/test/java/google/registry/tools/RenewDomainCommandTest.java
+++ b/core/src/test/java/google/registry/tools/RenewDomainCommandTest.java
@@ -15,21 +15,27 @@
 package google.registry.tools;
 
 import static com.google.common.truth.Truth.assertThat;
+import static google.registry.testing.DatastoreHelper.newDomainBase;
 import static google.registry.testing.DatastoreHelper.persistActiveDomain;
 import static google.registry.testing.DatastoreHelper.persistDeletedDomain;
+import static google.registry.testing.DatastoreHelper.persistNewRegistrar;
 import static google.registry.testing.DatastoreHelper.persistResource;
 import static org.junit.Assert.assertThrows;
 
 import com.beust.jcommander.ParameterException;
 import com.google.common.collect.ImmutableMap;
+import google.registry.model.domain.DomainBase;
 import google.registry.model.ofy.Ofy;
+import google.registry.model.registrar.Registrar;
 import google.registry.testing.FakeClock;
 import google.registry.testing.InjectRule;
 import google.registry.util.Clock;
+import java.util.List;
 import org.joda.time.DateTime;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
+import org.testcontainers.shaded.com.google.common.collect.ImmutableList;
 
 /** Unit tests for {@link RenewDomainCommand}. */
 public class RenewDomainCommandTest extends EppToolCommandTestCase<RenewDomainCommand> {
@@ -63,23 +69,57 @@ public class RenewDomainCommandTest extends EppToolCommandTestCase<RenewDomainCo
         .verifyNoMoreSent();
   }
 
+  private static List<DomainBase> persistThreeDomains() {
+    ImmutableList.Builder<DomainBase> domains = new ImmutableList.Builder<>();
+    domains.add(
+        persistActiveDomain(
+            "domain1.tld",
+            DateTime.parse("2014-09-05T05:05:05Z"),
+            DateTime.parse("2015-09-05T05:05:05Z")));
+    domains.add(
+        persistActiveDomain(
+            "domain2.tld",
+            DateTime.parse("2014-11-05T05:05:05Z"),
+            DateTime.parse("2015-11-05T05:05:05Z")));
+    // The third domain is owned by a different registrar.
+    domains.add(
+        persistResource(
+            newDomainBase("domain3.tld")
+                .asBuilder()
+                .setCreationTimeForTest(DateTime.parse("2015-01-05T05:05:05Z"))
+                .setRegistrationExpirationTime(DateTime.parse("2016-01-05T05:05:05Z"))
+                .setPersistedCurrentSponsorClientId("NewRegistrar")
+                .build()));
+    return domains.build();
+  }
+
   @Test
-  public void testSuccess_multipleDomains() throws Exception {
-    persistActiveDomain(
-        "domain1.tld",
-        DateTime.parse("2014-09-05T05:05:05Z"),
-        DateTime.parse("2015-09-05T05:05:05Z"));
-    persistActiveDomain(
-        "domain2.tld",
-        DateTime.parse("2014-11-05T05:05:05Z"),
-        DateTime.parse("2015-11-05T05:05:05Z"));
-    persistActiveDomain(
-        "domain3.tld",
-        DateTime.parse("2015-01-05T05:05:05Z"),
-        DateTime.parse("2016-01-05T05:05:05Z"));
+  public void testSuccess_multipleDomains_renewsAndUsesEachDomainsRegistrar() throws Exception {
+    persistThreeDomains();
     runCommandForced("--period 3", "domain1.tld", "domain2.tld", "domain3.tld");
     eppVerifier
         .expectClientId("TheRegistrar")
+        .verifySent(
+            "domain_renew.xml",
+            ImmutableMap.of("DOMAIN", "domain1.tld", "EXPDATE", "2015-09-05", "YEARS", "3"))
+        .verifySent(
+            "domain_renew.xml",
+            ImmutableMap.of("DOMAIN", "domain2.tld", "EXPDATE", "2015-11-05", "YEARS", "3"))
+        .expectClientId("NewRegistrar")
+        .verifySent(
+            "domain_renew.xml",
+            ImmutableMap.of("DOMAIN", "domain3.tld", "EXPDATE", "2016-01-05", "YEARS", "3"))
+        .verifyNoMoreSent();
+  }
+
+  @Test
+  public void testSuccess_multipleDomains_renewsAndUsesSpecifiedRegistrar() throws Exception {
+    persistThreeDomains();
+    persistNewRegistrar("reg3", "Registrar 3", Registrar.Type.REAL, 9783L);
+    runCommandForced("--period 3", "domain1.tld", "domain2.tld", "domain3.tld", "-u", "-c reg3");
+    eppVerifier
+        .expectClientId("reg3")
+        .expectSuperuser()
         .verifySent(
             "domain_renew.xml",
             ImmutableMap.of("DOMAIN", "domain1.tld", "EXPDATE", "2015-09-05", "YEARS", "3"))
@@ -106,9 +146,7 @@ public class RenewDomainCommandTest extends EppToolCommandTestCase<RenewDomainCo
     persistDeletedDomain("deleted.tld", DateTime.parse("2012-10-05T05:05:05Z"));
     IllegalArgumentException e =
         assertThrows(IllegalArgumentException.class, () -> runCommandForced("deleted.tld"));
-    assertThat(e)
-        .hasMessageThat()
-        .isEqualTo("Domain 'deleted.tld' does not exist or is deleted");
+    assertThat(e).hasMessageThat().isEqualTo("Domain 'deleted.tld' does not exist or is deleted");
   }
 
   @Test
@@ -128,9 +166,7 @@ public class RenewDomainCommandTest extends EppToolCommandTestCase<RenewDomainCo
     IllegalArgumentException e =
         assertThrows(
             IllegalArgumentException.class, () -> runCommandForced("domain.tld", "--period 10"));
-    assertThat(e)
-        .hasMessageThat()
-        .isEqualTo("Cannot renew domains for 10 or more years");
+    assertThat(e).hasMessageThat().isEqualTo("Cannot renew domains for 10 or more years");
   }
 
   @Test