diff --git a/src/app/core/submission/workflowitem-data.service.spec.ts b/src/app/core/submission/workflowitem-data.service.spec.ts
index f8a61c8647d..d4565dfea1f 100644
--- a/src/app/core/submission/workflowitem-data.service.spec.ts
+++ b/src/app/core/submission/workflowitem-data.service.spec.ts
@@ -12,6 +12,7 @@ import { RemoteDataBuildService } from '../cache/builders/remote-data-build.serv
 import { ObjectCacheService } from '../cache/object-cache.service';
 import { RestResponse } from '../cache/response.models';
 import { CoreState } from '../core-state.model';
+import { DefaultChangeAnalyzer } from '../data/default-change-analyzer.service';
 import { HrefOnlyDataService } from '../data/href-only-data.service';
 import { RequestService } from '../data/request.service';
 import { RequestEntry } from '../data/request-entry.model';
@@ -91,6 +92,7 @@ describe('WorkflowItemDataService test', () => {
       objectCache,
       halService,
       notificationsService,
+      new DefaultChangeAnalyzer(),
     );
   }
 
diff --git a/src/app/core/submission/workflowitem-data.service.ts b/src/app/core/submission/workflowitem-data.service.ts
index 6acbcc92852..b227e4c2bdf 100644
--- a/src/app/core/submission/workflowitem-data.service.ts
+++ b/src/app/core/submission/workflowitem-data.service.ts
@@ -1,5 +1,7 @@
 import { Injectable } from '@angular/core';
+import { RestRequestMethod } from '@dspace/config/rest-request-method';
 import { hasValue } from '@dspace/shared/utils/empty.util';
+import { Operation } from 'fast-json-patch';
 import { Observable } from 'rxjs';
 import {
   find,
@@ -14,10 +16,15 @@ import {
   DeleteDataImpl,
 } from '../data/base/delete-data';
 import { IdentifiableDataService } from '../data/base/identifiable-data.service';
+import {
+  PatchData,
+  PatchDataImpl,
+} from '../data/base/patch-data';
 import {
   SearchData,
   SearchDataImpl,
 } from '../data/base/search-data';
+import { DefaultChangeAnalyzer } from '../data/default-change-analyzer.service';
 import { FindListOptions } from '../data/find-list-options.model';
 import { PaginatedList } from '../data/paginated-list.model';
 import { RemoteData } from '../data/remote-data';
@@ -30,16 +37,27 @@ import { NoContent } from '../shared/NoContent.model';
 import { getFirstCompletedRemoteData } from '../shared/operators';
 import { WorkflowItem } from './models/workflowitem.model';
 
+/**
+ * Constructs an endpoint taking into account that the WorkflowItem's "uuid" has a prefix by removing that prefix from the ID
+ * @param endpoint    Endpoint to append ID to
+ * @param resourceID  WorkflowItem's "uuid" including the prefix to remove
+ */
+const constructWorkflowItemIdEndpoint = (endpoint, resourceID) => {
+  const regex = new RegExp(`^${WorkflowItem.type.value}-`);
+  return `${endpoint}/${resourceID.replace(regex, '')}`;
+};
+
 /**
  * A service that provides methods to make REST requests with workflow items endpoint.
  */
 @Injectable({ providedIn: 'root' })
-export class WorkflowItemDataService extends IdentifiableDataService<WorkflowItem> implements SearchData<WorkflowItem>, DeleteData<WorkflowItem> {
+export class WorkflowItemDataService extends IdentifiableDataService<WorkflowItem> implements SearchData<WorkflowItem>, DeleteData<WorkflowItem>, PatchData<WorkflowItem> {
   protected searchByItemLinkPath = 'item';
   protected responseMsToLive = 10 * 1000;
 
   private searchData: SearchDataImpl<WorkflowItem>;
   private deleteData: DeleteDataImpl<WorkflowItem>;
+  private patchData: PatchDataImpl<WorkflowItem>;
 
   constructor(
     protected requestService: RequestService,
@@ -47,11 +65,13 @@ export class WorkflowItemDataService extends IdentifiableDataService<WorkflowIte
     protected objectCache: ObjectCacheService,
     protected halService: HALEndpointService,
     protected notificationsService: NotificationsService,
+    protected comparator: DefaultChangeAnalyzer<WorkflowItem>,
   ) {
     super('workflowitems', requestService, rdbService, objectCache, halService);
 
     this.searchData = new SearchDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, this.responseMsToLive);
     this.deleteData = new DeleteDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, notificationsService, this.responseMsToLive, this.constructIdEndpoint);
+    this.patchData = new PatchDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, this.comparator, this.responseMsToLive, constructWorkflowItemIdEndpoint);
   }
 
   /**
@@ -148,4 +168,20 @@ export class WorkflowItemDataService extends IdentifiableDataService<WorkflowIte
   public deleteByHref(href: string, copyVirtualMetadata?: string[]): Observable<RemoteData<NoContent>> {
     return this.deleteData.deleteByHref(href, copyVirtualMetadata);
   }
+
+  commitUpdates(method?: RestRequestMethod): void {
+    this.patchData.commitUpdates(method);
+  }
+
+  createPatchFromCache(object: WorkflowItem): Observable<Operation[]> {
+    return this.patchData.createPatchFromCache(object);
+  }
+
+  patch(object: WorkflowItem, operations: Operation[]): Observable<RemoteData<WorkflowItem>> {
+    return this.patchData.patch(object, operations);
+  }
+
+  update(object: WorkflowItem): Observable<RemoteData<WorkflowItem>> {
+    return this.patchData.update(object);
+  }
 }
diff --git a/src/app/core/submission/workspaceitem-data.service.ts b/src/app/core/submission/workspaceitem-data.service.ts
index d8125c1c2a8..46df6094e98 100644
--- a/src/app/core/submission/workspaceitem-data.service.ts
+++ b/src/app/core/submission/workspaceitem-data.service.ts
@@ -3,8 +3,10 @@ import {
   HttpHeaders,
 } from '@angular/common/http';
 import { Injectable } from '@angular/core';
+import { RestRequestMethod } from '@dspace/config/rest-request-method';
 import { hasValue } from '@dspace/shared/utils/empty.util';
 import { Store } from '@ngrx/store';
+import { Operation } from 'fast-json-patch';
 import { Observable } from 'rxjs';
 import {
   find,
@@ -20,6 +22,10 @@ import {
   DeleteDataImpl,
 } from '../data/base/delete-data';
 import { IdentifiableDataService } from '../data/base/identifiable-data.service';
+import {
+  PatchData,
+  PatchDataImpl,
+} from '../data/base/patch-data';
 import {
   SearchData,
   SearchDataImpl,
@@ -37,15 +43,26 @@ import { HALEndpointService } from '../shared/hal-endpoint.service';
 import { NoContent } from '../shared/NoContent.model';
 import { WorkspaceItem } from './models/workspaceitem.model';
 
+/**
+ * Constructs an endpoint taking into account that the WorkspaceItem's "uuid" has a prefix by removing that prefix from the ID
+ * @param endpoint    Endpoint to append ID to
+ * @param resourceID  WorkspaceItem's "uuid" including the prefix to remove
+ */
+const constructWorkspaceItemIdEndpoint = (endpoint, resourceID) => {
+  const regex = new RegExp(`^${WorkspaceItem.type.value}-`);
+  return `${endpoint}/${resourceID.replace(regex, '')}`;
+};
+
 /**
  * A service that provides methods to make REST requests with workspaceitems endpoint.
  */
 @Injectable({ providedIn: 'root' })
-export class WorkspaceitemDataService extends IdentifiableDataService<WorkspaceItem> implements DeleteData<WorkspaceItem>, SearchData<WorkspaceItem>{
+export class WorkspaceitemDataService extends IdentifiableDataService<WorkspaceItem> implements DeleteData<WorkspaceItem>, SearchData<WorkspaceItem>, PatchData<WorkspaceItem> {
   protected linkPath = 'workspaceitems';
   protected searchByItemLinkPath = 'item';
   private deleteData: DeleteData<WorkspaceItem>;
   private searchData: SearchDataImpl<WorkspaceItem>;
+  private patchData: PatchDataImpl<WorkspaceItem>;
 
   constructor(
     protected comparator: DSOChangeAnalyzer<WorkspaceItem>,
@@ -55,10 +72,12 @@ export class WorkspaceitemDataService extends IdentifiableDataService<WorkspaceI
     protected requestService: RequestService,
     protected rdbService: RemoteDataBuildService,
     protected objectCache: ObjectCacheService,
-    protected store: Store<CoreState>) {
+    protected store: Store<CoreState>,
+  ) {
     super('workspaceitems', requestService, rdbService, objectCache, halService);
     this.deleteData = new DeleteDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, notificationsService, this.responseMsToLive, this.constructIdEndpoint);
     this.searchData = new SearchDataImpl(this.linkPath, requestService, rdbService, objectCache, halService, this.responseMsToLive);
+    this.patchData = new PatchDataImpl<WorkspaceItem>(this.linkPath, requestService, rdbService, objectCache, halService, this.comparator, this.responseMsToLive, constructWorkspaceItemIdEndpoint);
   }
   public delete(objectId: string, copyVirtualMetadata?: string[]): Observable<RemoteData<NoContent>> {
     return this.deleteData.delete(objectId, copyVirtualMetadata);
@@ -137,4 +156,21 @@ export class WorkspaceitemDataService extends IdentifiableDataService<WorkspaceI
   searchBy(searchMethod: string, options?: FindListOptions, useCachedVersionIfAvailable?: boolean, reRequestOnStale?: boolean, ...linksToFollow: FollowLinkConfig<WorkspaceItem>[]): Observable<RemoteData<PaginatedList<WorkspaceItem>>> {
     return this.searchData.searchBy(searchMethod, options, useCachedVersionIfAvailable, reRequestOnStale, ...linksToFollow);
   }
+
+  commitUpdates(method?: RestRequestMethod): void {
+    this.patchData.commitUpdates(method);
+  }
+
+  createPatchFromCache(object: WorkspaceItem): Observable<Operation[]> {
+    return this.patchData.createPatchFromCache(object);
+  }
+
+  patch(object: WorkspaceItem, operations: Operation[]): Observable<RemoteData<WorkspaceItem>> {
+    return this.patchData.patch(object, operations);
+  }
+
+  update(object: WorkspaceItem): Observable<RemoteData<WorkspaceItem>> {
+    return this.patchData.update(object);
+  }
+
 }
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.spec.ts
index 8fb617d0336..b76f4567996 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.spec.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.spec.ts
@@ -276,6 +276,7 @@ describe('DsDynamicFormControlContainerComponent test suite', () => {
         { provide: DYNAMIC_FORM_CONTROL_MAP_FN, useValue: dsDynamicFormControlMapFn },
         { provide: LiveRegionService, useValue: getLiveRegionServiceStub() },
         { provide: Actions, useValue: actions$ },
+        { provide: 'sectionDataProvider', useValue: { id: 'mock-section-id' } },
       ],
       schemas: [CUSTOM_ELEMENTS_SCHEMA],
     }).compileComponents().then(() => {
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts
index 3bdd5d67f44..d6d888c9c6c 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts
@@ -19,6 +19,7 @@ import {
   OnChanges,
   OnDestroy,
   OnInit,
+  Optional,
   Output,
   PLATFORM_ID,
   QueryList,
@@ -124,6 +125,7 @@ import {
 import { AppState } from '../../../../app.reducer';
 import { EditMetadataSecurityComponent } from '../../../../item-page/edit-item-page/edit-metadata-security/edit-metadata-security.component';
 import { SubmissionObjectActionTypes } from '../../../../submission/objects/submission-objects.actions';
+import { SectionDataObject } from '../../../../submission/sections/models/section-data.model';
 import { SubmissionService } from '../../../../submission/submission.service';
 import { SubmissionObjectService } from '../../../../submission/submission-object.service';
 import { LiveRegionService } from '../../../live-region/live-region.service';
@@ -174,6 +176,7 @@ export class DsDynamicFormControlContainerComponent extends DynamicFormControlCo
   @Input() hasErrorMessaging = false;
   @Input() layout = null as DynamicFormLayout;
   @Input() model: any;
+  @Input() arrayIndex: number;
   securityLevel: number;
   relationshipValue$: Observable<ReorderableRelationship>;
   isRelationship: boolean;
@@ -235,6 +238,7 @@ export class DsDynamicFormControlContainerComponent extends DynamicFormControlCo
     private actions$: Actions,
     protected renderer: Renderer2,
     @Inject(PLATFORM_ID) protected platformId: string,
+    @Optional() @Inject('sectionDataProvider') public sectionData: SectionDataObject,
   ) {
     super(ref, componentFactoryResolver, layoutService, validationService, dynamicFormComponentService, relationService);
     this.fetchThumbnail = this.appConfig.browseBy.showThumbnails;
@@ -485,6 +489,13 @@ export class DsDynamicFormControlContainerComponent extends DynamicFormControlCo
       } else if (typeof this.model.value.value === 'string') {
         modalComp.query = this.model.value.value;
       }
+
+      // If the existing value is not virtual, store properties on the modal required to perform a replace operation
+      if (hasValue(this.sectionData) && !this.model.value.isVirtual) {
+        modalComp.replaceValuePlace = this.arrayIndex || 0;
+        modalComp.replaceValueMetadataField = this.model.name;
+        modalComp.replaceValueSection = this.sectionData?.id;
+      }
     }
 
     modalComp.repeatable = this.model.repeatable;
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.html b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.html
index 73cae52db2e..dd92d28bb21 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.html
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.html
@@ -40,6 +40,7 @@
               [class.d-none]="_model.hidden"
               [layout]="formLayout"
               [model]="_model"
+              [arrayIndex]="idx"
               [templates]="templates"
               [ngClass]="[getClass('element', 'host', _model), getClass('grid', 'host', _model)]"
               (dfBlur)="onBlur($event)"
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.spec.ts
index 1c808b0ba84..aae47ed3a4b 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.spec.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.spec.ts
@@ -69,6 +69,7 @@ describe('DsDynamicFormArrayComponent', () => {
         { provide: APP_CONFIG, useValue: environment },
         { provide: DYNAMIC_FORM_CONTROL_MAP_FN, useValue: dsDynamicFormControlMapFn },
         { provide: LiveRegionService, useValue: getLiveRegionServiceStub() },
+        { provide: 'sectionDataProvider', useValue: { id: 'mock-section-id' } },
       ],
     }).overrideComponent(DsDynamicFormArrayComponent, {
       remove: {
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/relation-group/dynamic-relation-group.component.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/relation-group/dynamic-relation-group.component.spec.ts
index 0a40950997b..fa44cf3b539 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/relation-group/dynamic-relation-group.component.spec.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/relation-group/dynamic-relation-group.component.spec.ts
@@ -255,6 +255,7 @@ describe('DsDynamicRelationGroupComponent test suite', () => {
         { provide: APP_DATA_SERVICES_MAP, useValue: {} },
         { provide: DYNAMIC_FORM_CONTROL_MAP_FN, useValue: dsDynamicFormControlMapFn },
         { provide: LiveRegionService, useValue: getLiveRegionServiceStub() },
+        { provide: 'sectionDataProvider', useValue: { id: 'mock-section-id' } },
       ],
       schemas: [CUSTOM_ELEMENTS_SCHEMA],
     })
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.html b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.html
index 9e2a8fe5137..8e698d2c103 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.html
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.html
@@ -5,10 +5,10 @@ <h4 class="modal-title" id="modal-title">{{ ('submission.sections.describe.relat
   </button>
 </div>
 <div class="modal-body">
-  @if (!item || !collection) {
+  @if (!item || !collection || isSubmitting) {
     <ds-loading></ds-loading>
   }
-  @if (item && collection) {
+  @if (item && collection && !isSubmitting) {
     <ul ngbNav #nav="ngbNav" class="nav-tabs">
       <li ngbNavItem role="presentation">
         <a ngbNavLink>{{'submission.sections.describe.relationship-lookup.search-tab.tab-title.' + relationshipOptions.relationshipType | translate  : { count: (totalInternal$ | async)} }}</a>
@@ -78,18 +78,18 @@ <h4 class="modal-title" id="modal-title">{{ ('submission.sections.describe.relat
   <small>{{ ('submission.sections.describe.relationship-lookup.selected' | translate: {size: (selection$ | async)?.length || 0}) }}</small>
   <div class="d-flex float-end space-children-mr">
     <div class="close-button">
-      <button type="button" [dsBtnDisabled]="isPending" class="btn btn-outline-secondary" (click)="close()">
+      <button type="button" [dsBtnDisabled]="isPending || isSubmitting" class="btn btn-outline-secondary" (click)="close()">
       {{ ('submission.sections.describe.relationship-lookup.close' | translate) }}</button>
     </div>
     @if (isEditRelationship) {
       <button class="btn btn-danger discard"
-        [dsBtnDisabled]="(toAdd.length === 0 && toRemove.length === 0) || isPending"
+        [dsBtnDisabled]="(toAdd.length === 0 && toRemove.length === 0) || isPending || isSubmitting"
         (click)="discardEv()">
         <i class="fas fa-times"></i>
         <span class="d-none d-sm-inline">&nbsp;{{"item.edit.metadata.discard-button" | translate}}</span>
       </button>
       <button class="btn btn-primary submit"
-        [dsBtnDisabled]="(toAdd.length === 0 && toRemove.length === 0) || isPending"
+        [dsBtnDisabled]="(toAdd.length === 0 && toRemove.length === 0) || isPending || isSubmitting"
         (click)="submitEv()">
         @if (isPending) {
           <span class="spinner-border spinner-border-sm me-1" role="status"
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.spec.ts
index 30b54f9df16..c9d0bbc7ad8 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.spec.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.spec.ts
@@ -45,7 +45,9 @@ import { NameVariantService } from './name-variant.service';
 import {
   AddRelationshipAction,
   RemoveRelationshipAction,
+  ReplaceRelationshipAction,
 } from './relationship.actions';
+import { SubmissionService } from '../../../../../submission/submission.service';
 
 describe('DsDynamicLookupRelationModalComponent', () => {
   let component: DsDynamicLookupRelationModalComponent;
@@ -54,9 +56,11 @@ describe('DsDynamicLookupRelationModalComponent', () => {
   let item;
   let item1;
   let item2;
+  let item3;
   let testWSI;
   let searchResult1;
   let searchResult2;
+  let searchResult3;
   let listID;
   let selection$;
   let selectableListService;
@@ -68,6 +72,7 @@ describe('DsDynamicLookupRelationModalComponent', () => {
   let lookupRelationService;
   let rdbService;
   let submissionId;
+  let submissionService;
 
   const externalSources = [
     Object.assign(new ExternalSource(), {
@@ -90,11 +95,13 @@ describe('DsDynamicLookupRelationModalComponent', () => {
     item = Object.assign(new Item(), { uuid: '7680ca97-e2bd-4398-bfa7-139a8673dc42', metadata: {} });
     item1 = Object.assign(new Item(), { uuid: 'e1c51c69-896d-42dc-8221-1d5f2ad5516e' });
     item2 = Object.assign(new Item(), { uuid: 'c8279647-1acc-41ae-b036-951d5f65649b' });
+    item3 = Object.assign(new Item(), { uuid: '6264b66f-ae25-4221-b72a-8696536c5ebb' });
     testWSI = new WorkspaceItem();
     testWSI.item = createSuccessfulRemoteDataObject$(item);
     testWSI.collection = createSuccessfulRemoteDataObject$(collection);
     searchResult1 = Object.assign(new ItemSearchResult(), { indexableObject: item1 });
     searchResult2 = Object.assign(new ItemSearchResult(), { indexableObject: item2 });
+    searchResult3 = Object.assign(new ItemSearchResult(), { indexableObject: item3 });
     listID = '6b0c8221-fcb4-47a8-b483-ca32363fffb3';
     selection$ = of([searchResult1, searchResult2]);
     selectableListService = { getSelectableList: () => selection$ };
@@ -120,6 +127,9 @@ describe('DsDynamicLookupRelationModalComponent', () => {
       aggregate: createSuccessfulRemoteDataObject$(externalSources),
     });
     submissionId = '1234';
+    submissionService = jasmine.createSpyObj('submissionService', {
+      getSubmissionSaveProcessingStatus: observableOf(false),
+    });
   }
 
   beforeEach(waitForAsync(() => {
@@ -151,6 +161,7 @@ describe('DsDynamicLookupRelationModalComponent', () => {
         },
         { provide: XSRFService, useValue: {} },
         { provide: NgZone, useValue: new NgZone({}) },
+        { provide: SubmissionService, useValue: submissionService },
         { provide: APP_DATA_SERVICES_MAP, useValue: {} },
         { provide: APP_CONFIG, useValue: { cache: { msToLive: { default: 15 * 60 * 1000 } } } },
         NgbActiveModal,
@@ -197,13 +208,39 @@ describe('DsDynamicLookupRelationModalComponent', () => {
       spyOn((component as any).store, 'dispatch');
     });
 
-    it('should dispatch an AddRelationshipAction for each selected object', () => {
-      component.select(searchResult1, searchResult2);
-      const action = new AddRelationshipAction(component.item, searchResult1.indexableObject, relationship.relationshipType, submissionId, nameVariant);
-      const action2 = new AddRelationshipAction(component.item, searchResult2.indexableObject, relationship.relationshipType, submissionId, nameVariant);
+    describe('when replace properties are present', () => {
+      beforeEach(() => {
+        component.replaceValuePlace = 3;
+        component.replaceValueMetadataField = 'dc.subject';
+        component.replaceValueSection = 'traditionalpageone';
+      });
 
-      expect((component as any).store.dispatch).toHaveBeenCalledWith(action);
-      expect((component as any).store.dispatch).toHaveBeenCalledWith(action2);
+      it('should dispatch a ReplaceRelationshipAction for the first selected object and a AddRelationshipAction for every other selected object', () => {
+        component.select(searchResult1, searchResult2, searchResult3);
+        const action1 = new ReplaceRelationshipAction(component.item, searchResult1.indexableObject, true, 3, 'dc.subject', 'traditionalpageone', relationship.relationshipType, submissionId, nameVariant);
+        const action2 = new AddRelationshipAction(component.item, searchResult2.indexableObject, relationship.relationshipType, submissionId, nameVariant);
+        const action3 = new AddRelationshipAction(component.item, searchResult3.indexableObject, relationship.relationshipType, submissionId, nameVariant);
+
+        expect((component as any).store.dispatch).toHaveBeenCalledWith(action1);
+        expect((component as any).store.dispatch).toHaveBeenCalledWith(action2);
+        expect((component as any).store.dispatch).toHaveBeenCalledWith(action3);
+        expect(component.replaceValuePlace).toBeUndefined();
+        expect(component.replaceValueMetadataField).toBeUndefined();
+        expect(component.replaceValueSection).toBeUndefined();
+      });
+    });
+
+    describe('when replace properties are missing', () => {
+      it('should dispatch an AddRelationshipAction for each selected object', () => {
+        component.select(searchResult1, searchResult2, searchResult3);
+        const action1 = new AddRelationshipAction(component.item, searchResult1.indexableObject, relationship.relationshipType, submissionId, nameVariant);
+        const action2 = new AddRelationshipAction(component.item, searchResult2.indexableObject, relationship.relationshipType, submissionId, nameVariant);
+        const action3 = new AddRelationshipAction(component.item, searchResult3.indexableObject, relationship.relationshipType, submissionId, nameVariant);
+
+        expect((component as any).store.dispatch).toHaveBeenCalledWith(action1);
+        expect((component as any).store.dispatch).toHaveBeenCalledWith(action2);
+        expect((component as any).store.dispatch).toHaveBeenCalledWith(action3);
+      });
     });
   });
 
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.ts
index 4ef5273299a..3711731a74f 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/dynamic-lookup-relation-modal.component.ts
@@ -67,10 +67,12 @@ import { NameVariantService } from './name-variant.service';
 import {
   AddRelationshipAction,
   RemoveRelationshipAction,
+  ReplaceRelationshipAction,
   UpdateRelationshipNameVariantAction,
 } from './relationship.actions';
 import { ThemedDynamicLookupRelationSearchTabComponent } from './search-tab/themed-dynamic-lookup-relation-search-tab.component';
 import { DsDynamicLookupRelationSelectionTabComponent } from './selection-tab/dynamic-lookup-relation-selection-tab.component';
+import { SubmissionService } from '../../../../../submission/submission.service';
 
 @Component({
   selector: 'ds-dynamic-lookup-relation-modal',
@@ -156,6 +158,22 @@ export class DsDynamicLookupRelationModalComponent implements OnInit, OnDestroy
    */
   hiddenQuery: string;
 
+  /**
+   * The index of the plain-text value that should be replaced by adding a relationship
+   */
+  replaceValuePlace: number;
+
+  /**
+   * The metadata field of the value to replace with a relationship
+   * Undefined if no value needs replacing
+   */
+  replaceValueMetadataField: string;
+
+  /**
+   * The submission section of the plain-text value that should be replaced by adding a relationship
+   */
+  replaceValueSection: string;
+
   /**
    * A map of subscriptions within this component
    */
@@ -214,6 +232,16 @@ export class DsDynamicLookupRelationModalComponent implements OnInit, OnDestroy
    */
   isPending = false;
 
+  /**
+   * Show a loading indicator if the form is currently submitting to avoid race conditions between requests
+   */
+  isSubmitting = false;
+
+  /**
+   * Open subscriptions
+   */
+  subs = [];
+
   constructor(
     public modal: NgbActiveModal,
     private selectableListService: SelectableListService,
@@ -225,6 +253,7 @@ export class DsDynamicLookupRelationModalComponent implements OnInit, OnDestroy
     private zone: NgZone,
     private store: Store<AppState>,
     private router: Router,
+    protected submissionService: SubmissionService,
   ) {
 
   }
@@ -277,6 +306,14 @@ export class DsDynamicLookupRelationModalComponent implements OnInit, OnDestroy
         }));
     }
 
+    if (hasValue(this.submissionId)) {
+      this.subs.push(
+        this.submissionService.getSubmissionSaveProcessingStatus(this.submissionId).subscribe((isSubmitting) => {
+          this.isSubmitting = isSubmitting;
+        }),
+      );
+    }
+
     this.setTotals();
   }
 
@@ -310,9 +347,17 @@ export class DsDynamicLookupRelationModalComponent implements OnInit, OnDestroy
         ]);
         obs
           .subscribe((arr: any[]) => {
-            return arr.forEach((object: any) => {
-              const addRelationshipAction = new AddRelationshipAction(this.item, object.item, this.relationshipOptions.relationshipType, this.submissionId, object.nameVariant);
-              this.store.dispatch(addRelationshipAction);
+            return arr.forEach((object: any, i: number) => {
+              let action;
+              if (i === 0 && hasValue(this.replaceValueMetadataField)) {
+                // This is the first action this modal performs and "replace" properties are present to replace an existing metadata value
+                action = new ReplaceRelationshipAction(this.item, object.item, true, this.replaceValuePlace, this.replaceValueMetadataField, this.replaceValueSection, this.relationshipOptions.relationshipType, this.submissionId, object.nameVariant);
+                // Only "replace" once, reset replace properties so future actions become "add"
+                this.resetReplaceProperties();
+              } else {
+                action = new AddRelationshipAction(this.item, object.item, this.relationshipOptions.relationshipType, this.submissionId, object.nameVariant);
+              }
+              this.store.dispatch(action);
             },
             );
           });
@@ -335,6 +380,7 @@ export class DsDynamicLookupRelationModalComponent implements OnInit, OnDestroy
    * @param selectableObjects
    */
   deselect(...selectableObjects: SearchResult<DSpaceObject>[]) {
+    this.resetReplaceProperties();
     this.zone.runOutsideAngular(
       () => selectableObjects.forEach((object) => {
         this.subMap[object.indexableObject.uuid].unsubscribe();
@@ -372,9 +418,16 @@ export class DsDynamicLookupRelationModalComponent implements OnInit, OnDestroy
     this.totalInternal$.next(totalPages);
   }
 
+  private resetReplaceProperties() {
+    this.replaceValueMetadataField = undefined;
+    this.replaceValuePlace = undefined;
+    this.replaceValueSection = undefined;
+  }
+
   ngOnDestroy() {
     this.router.navigate([], {});
     Object.values(this.subMap).forEach((subscription) => subscription.unsubscribe());
+    this.subs.filter((sub) => hasValue(sub)).forEach((sub) => sub.unsubscribe());
   }
 
   /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.actions.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.actions.ts
index 6826ac04b8e..d823bbab89f 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.actions.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.actions.ts
@@ -9,6 +9,7 @@ import { Action } from '@ngrx/store';
 
 export const RelationshipActionTypes = {
   ADD_RELATIONSHIP: type('dspace/relationship/ADD_RELATIONSHIP'),
+  REPLACE_RELATIONSHIP: type('dspace/relationship/REPLACE_RELATIONSHIP'),
   REMOVE_RELATIONSHIP: type('dspace/relationship/REMOVE_RELATIONSHIP'),
   UPDATE_NAME_VARIANT: type('dspace/relationship/UPDATE_NAME_VARIANT'),
   UPDATE_RELATIONSHIP: type('dspace/relationship/UPDATE_RELATIONSHIP'),
@@ -132,10 +133,56 @@ export class RemoveRelationshipAction implements Action {
   }
 }
 
+/**
+ * An ngrx action to replace a plain-text metadata value with a new relationship
+ */
+export class ReplaceRelationshipAction implements Action {
+  type = RelationshipActionTypes.REPLACE_RELATIONSHIP;
+
+  payload: {
+    item1: Item;
+    item2: Item;
+    replaceLeftSide: boolean;
+    place: number;
+    mdField: string;
+    section: string;
+    relationshipType: string;
+    submissionId: string;
+    nameVariant: string;
+  };
+
+  /**
+   * Create a new AddRelationshipAction
+   *
+   * @param item1 The first item in the relationship
+   * @param item2 The second item in the relationship
+   * @param replaceLeftSide If true, the item on the left side (item1) will have its metadata value replaced
+   * @param place The index of the metadata value that should be replaced with the new relationship
+   * @param mdField The metadata field of the value to replace
+   * @param section The submission section of the value to replace
+   * @param relationshipType The label of the relationshipType
+   * @param submissionId The current submissionId
+   * @param nameVariant The nameVariant of the relationshipType
+   */
+  constructor(
+    item1: Item,
+    item2: Item,
+    replaceLeftSide: boolean,
+    place: number,
+    mdField: string,
+    section: string,
+    relationshipType: string,
+    submissionId: string,
+    nameVariant?: string,
+  ) {
+    this.payload = { item1, item2, replaceLeftSide, place, mdField, section, relationshipType, submissionId, nameVariant };
+  }
+}
 
 /**
  * A type to encompass all RelationshipActions
  */
 export type RelationshipAction
   = AddRelationshipAction
+  | ReplaceRelationshipAction
   | RemoveRelationshipAction;
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.spec.ts
index 49dd524c9ca..9729795c0c0 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.spec.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.spec.ts
@@ -30,12 +30,14 @@ import {
 } from 'rxjs';
 import { last } from 'rxjs/operators';
 
+import { ItemDataService } from '../../../../../core/data/item-data.service';
 import { SubmissionObjectService } from '../../../../../submission/submission-object.service';
 import { SelectableListService } from '../../../../object-list/selectable-list/selectable-list.service';
 import {
   AddRelationshipAction,
   RelationshipActionTypes,
   RemoveRelationshipAction,
+  ReplaceRelationshipAction,
 } from './relationship.actions';
 import { RelationshipEffects } from './relationship.effects';
 
@@ -66,6 +68,7 @@ describe('RelationshipEffects', () => {
   let notificationsService;
   let translateService;
   let selectableListService;
+  let itemService;
 
   function init() {
     testUUID1 = '20e24c2f-a00a-467c-bdee-c929e79bf08d';
@@ -108,8 +111,8 @@ describe('RelationshipEffects', () => {
       getRelationshipByItemsAndLabel:
         () => of(relationship),
       deleteRelationship: () => of(new RestResponse(true, 200, 'OK')),
-      addRelationship: () => of(new RestResponse(true, 200, 'OK')),
-
+      addRelationship: () => createSuccessfulRemoteDataObject$(new Relationship()),
+      update: () => createSuccessfulRemoteDataObject$(new Relationship()),
     };
     mockRelationshipTypeService = {
       getRelationshipTypeByLabelAndTypes:
@@ -123,6 +126,9 @@ describe('RelationshipEffects', () => {
       findSelectedByCondition: of({}),
       deselectSingle: {},
     });
+    itemService = jasmine.createSpyObj('itemService', {
+      patch: createSuccessfulRemoteDataObject$(new Item()),
+    });
   }
 
   beforeEach(waitForAsync(() => {
@@ -133,6 +139,7 @@ describe('RelationshipEffects', () => {
         provideMockActions(() => actions),
         { provide: RelationshipTypeDataService, useValue: mockRelationshipTypeService },
         { provide: RelationshipDataService, useValue: mockRelationshipService },
+        { provide: ItemDataService, useValue: itemService },
         {
           provide: SubmissionObjectService, useValue: {
             findById: () => createSuccessfulRemoteDataObject$(new WorkspaceItem()),
@@ -155,6 +162,7 @@ describe('RelationshipEffects', () => {
     identifier = (relationEffects as any).createIdentifier(leftItem, rightItem, relationshipType.leftwardType);
     spyOn((relationEffects as any), 'addRelationship').and.stub();
     spyOn((relationEffects as any), 'removeRelationship').and.stub();
+    spyOn((relationEffects as any), 'replaceRelationship').and.stub();
   });
 
   describe('mapLastActions$', () => {
@@ -225,6 +233,75 @@ describe('RelationshipEffects', () => {
       });
     });
 
+    describe('When a REPLACE_RELATIONSHIP action is triggered', () => {
+      describe('When it\'s the first time for this identifier', () => {
+        let action;
+
+        it('should set the current value debounceMap and the value of the initialActionMap to REPLACE_RELATIONSHIP', () => {
+          action = new ReplaceRelationshipAction(leftItem, rightItem, true, 0, 'dc.subject', 'traditionalpageone', relationshipType.leftwardType, '1234');
+          actions = hot('--a-|', { a: action });
+          const expected = cold('--b-|', { b: undefined });
+          expect(relationEffects.mapLastActions$).toBeObservable(expected);
+
+          expect((relationEffects as any).initialActionMap[identifier]).toBe(action.type);
+          expect((relationEffects as any).debounceMap[identifier].value).toBe(action.type);
+        });
+      });
+
+      describe('When it\'s not the first time for this identifier', () => {
+        let action;
+        const testActionType = 'TEST_TYPE';
+        beforeEach(() => {
+          (relationEffects as any).initialActionMap[identifier] = testActionType;
+          (relationEffects as any).debounceMap[identifier] = new BehaviorSubject<string>(testActionType);
+        });
+
+        it('should set the current value debounceMap to REPLACE_RELATIONSHIP but not change the value of the initialActionMap', () => {
+          action = new ReplaceRelationshipAction(leftItem, rightItem, true, 0, 'dc.subject', 'traditionalpageone', relationshipType.leftwardType, '1234');
+          actions = hot('--a-|', { a: action });
+
+          const expected = cold('--b-|', { b: undefined });
+          expect(relationEffects.mapLastActions$).toBeObservable(expected);
+
+          expect((relationEffects as any).initialActionMap[identifier]).toBe(testActionType);
+          expect((relationEffects as any).debounceMap[identifier].value).toBe(action.type);
+        });
+      });
+
+      describe('When the initialActionMap contains a REPLACE_RELATIONSHIP action', () => {
+        let action;
+        describe('When the last value in the debounceMap is also a REPLACE_RELATIONSHIP action', () => {
+          beforeEach(() => {
+            jasmine.getEnv().allowRespy(true);
+            spyOn((relationEffects as any), 'replaceRelationship').and.returnValue(createSuccessfulRemoteDataObject$(relationship));
+            spyOn((relationEffects as any).relationshipService, 'update').and.callThrough();
+            ((relationEffects as any).debounceTime as jasmine.Spy).and.returnValue((v) => v);
+            (relationEffects as any).initialActionMap[identifier] = RelationshipActionTypes.REPLACE_RELATIONSHIP;
+          });
+
+          it('should call replaceRelationship on the effect', () => {
+            action = new ReplaceRelationshipAction(leftItem, rightItem, true, 0, 'dc.subject', 'traditionalpageone', relationshipType.leftwardType, '1234');
+            actions = hot('--a-|', { a: action });
+            const expected = cold('--b-|', { b: undefined });
+            expect(relationEffects.mapLastActions$).toBeObservable(expected);
+            expect((relationEffects as any).replaceRelationship).toHaveBeenCalledWith(leftItem, rightItem, true, 0, 'dc.subject', 'traditionalpageone', relationshipType.leftwardType, '1234', undefined);
+          });
+        });
+
+        describe('When the last value in the debounceMap is instead a REMOVE_RELATIONSHIP action', () => {
+          it('should <b>not</b> call removeRelationship or replaceRelationship on the effect', () => {
+            const actiona = new ReplaceRelationshipAction(leftItem, rightItem, true, 0, 'dc.subject', 'traditionalpageone', relationshipType.leftwardType, '1234');
+            const actionb = new RemoveRelationshipAction(leftItem, rightItem, relationshipType.leftwardType, '1234');
+            actions = hot('--ab-|', { a: actiona, b: actionb });
+            const expected = cold('--bb-|', { b: undefined });
+            expect(relationEffects.mapLastActions$).toBeObservable(expected);
+            expect((relationEffects as any).replaceRelationship).not.toHaveBeenCalled();
+            expect((relationEffects as any).removeRelationship).not.toHaveBeenCalled();
+          });
+        });
+      });
+    });
+
     describe('When an REMOVE_RELATIONSHIP action is triggered', () => {
       describe('When it\'s the first time for this identifier', () => {
         let action;
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.ts
index 8e27fb539e7..63796e82af2 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/relationship.effects.ts
@@ -17,6 +17,7 @@ import { Relationship } from '@dspace/core/shared/item-relationships/relationshi
 import { RelationshipType } from '@dspace/core/shared/item-relationships/relationship-type.model';
 import {
   DEBOUNCE_TIME_OPERATOR,
+  getFirstCompletedRemoteData,
   getFirstSucceededRemoteData,
   getRemoteDataPayload,
 } from '@dspace/core/shared/operators';
@@ -33,6 +34,7 @@ import {
 } from '@ngrx/effects';
 import { Store } from '@ngrx/store';
 import { TranslateService } from '@ngx-translate/core';
+import { Operation } from 'fast-json-patch';
 import {
   BehaviorSubject,
   Observable,
@@ -45,7 +47,6 @@ import {
   mergeMap,
   switchMap,
   take,
-  tap,
 } from 'rxjs/operators';
 
 import { SaveSubmissionSectionFormSuccessAction } from '../../../../../submission/objects/submission-objects.actions';
@@ -56,6 +57,7 @@ import {
   AddRelationshipAction,
   RelationshipAction,
   RelationshipActionTypes,
+  ReplaceRelationshipAction,
   UpdateRelationshipAction,
   UpdateRelationshipNameVariantAction,
 } from './relationship.actions';
@@ -65,6 +67,7 @@ const DEBOUNCE_TIME = 500;
 enum RelationOperationType {
   Add,
   Remove,
+  Replace,
 }
 
 interface RelationOperation {
@@ -74,6 +77,10 @@ interface RelationOperation {
   relationshipType: string
   submissionId: string
   nameVariant?: string
+  replaceLeftSide?: boolean
+  place?: number
+  mdField?: string
+  section?: string
 }
 
 /**
@@ -109,7 +116,7 @@ export class RelationshipEffects {
    */
   mapLastActions$ = createEffect(() => this.actions$
     .pipe(
-      ofType(RelationshipActionTypes.ADD_RELATIONSHIP, RelationshipActionTypes.REMOVE_RELATIONSHIP),
+      ofType(RelationshipActionTypes.ADD_RELATIONSHIP, RelationshipActionTypes.REPLACE_RELATIONSHIP, RelationshipActionTypes.REMOVE_RELATIONSHIP),
       map((action: RelationshipAction) => {
         const { item1, item2, submissionId, relationshipType } = action.payload;
         const identifier: string = this.createIdentifier(item1, item2, relationshipType);
@@ -122,20 +129,36 @@ export class RelationshipEffects {
           ).subscribe(
             (type) => {
               if (this.initialActionMap[identifier] === type) {
-                if (type === RelationshipActionTypes.ADD_RELATIONSHIP) {
+                if (type === RelationshipActionTypes.ADD_RELATIONSHIP || type === RelationshipActionTypes.REPLACE_RELATIONSHIP) {
                   let nameVariant = (action as AddRelationshipAction).payload.nameVariant;
                   if (hasValue(this.nameVariantUpdates[identifier])) {
                     nameVariant = this.nameVariantUpdates[identifier];
                     delete this.nameVariantUpdates[identifier];
                   }
-                  this.requestQueue.next({
-                    type: RelationOperationType.Add,
-                    item1,
-                    item2,
-                    relationshipType,
-                    submissionId,
-                    nameVariant,
-                  });
+                  if (type === RelationshipActionTypes.ADD_RELATIONSHIP) {
+                    this.requestQueue.next({
+                      type: RelationOperationType.Add,
+                      item1,
+                      item2,
+                      relationshipType,
+                      submissionId,
+                      nameVariant,
+                    });
+                  } else {
+                    const replaceAction = action as ReplaceRelationshipAction;
+                    this.requestQueue.next({
+                      type: RelationOperationType.Replace,
+                      item1,
+                      item2,
+                      relationshipType,
+                      submissionId,
+                      nameVariant,
+                      replaceLeftSide: replaceAction.payload.replaceLeftSide,
+                      place: replaceAction.payload.place,
+                      mdField: replaceAction.payload.mdField,
+                      section: replaceAction.payload.section,
+                    });
+                  }
                 } else {
                   this.requestQueue.next({
                     type: RelationOperationType.Remove,
@@ -237,6 +260,10 @@ export class RelationshipEffects {
             return this.addRelationship(next.item1, next.item2, next.relationshipType, next.submissionId, next.nameVariant).pipe(
               map(() => next),
             );
+          case RelationOperationType.Replace:
+            return this.replaceRelationship(next.item1, next.item2, next.replaceLeftSide, next.place, next.mdField, next.section, next.relationshipType, next.submissionId, next.nameVariant).pipe(
+              map(() => next),
+            );
           case RelationOperationType.Remove:
             return this.removeRelationship(next.item1, next.item2, next.relationshipType).pipe(
               map(() => next),
@@ -259,7 +286,7 @@ export class RelationshipEffects {
     return `${item1.uuid}-${item2.uuid}-${relationshipType}`;
   }
 
-  private addRelationship(item1: Item, item2: Item, relationshipType: string, submissionId: string, nameVariant?: string) {
+  private addRelationship(item1: Item, item2: Item, relationshipType: string, submissionId: string, nameVariant?: string): Observable<Relationship> {
     const type1: string = item1.firstMetadataValue('dspace.entity.type');
     const type2: string = item2.firstMetadataValue('dspace.entity.type');
     return this.relationshipTypeService.getRelationshipTypeByLabelAndTypes(relationshipType, type1, type2)
@@ -277,28 +304,94 @@ export class RelationshipEffects {
           }
         }),
         take(1),
-        tap((rd: RemoteData<Relationship>) => {
+        map((rd: RemoteData<Relationship>) => {
           if (hasNoValue(rd) || rd.hasFailed) {
             // An error occurred, deselect the object from the selectable list and display an error notification
-            const listId = `list-${submissionId}-${relationshipType}`;
-            this.selectableListService.findSelectedByCondition(listId, (object: any) => hasValue(object.indexableObject) && object.indexableObject.uuid === item2.uuid).pipe(
-              take(1),
-              hasValueOperator(),
-            ).subscribe((selected) => {
-              this.selectableListService.deselectSingle(listId, selected);
-            });
-            let errorContent;
-            if (hasNoValue(rd)) {
-              errorContent = this.translateService.instant('relationships.add.error.relationship-type.content', { type: relationshipType });
-            } else {
-              errorContent = this.translateService.instant('relationships.add.error.server.content');
-            }
-            this.notificationsService.error(this.translateService.instant('relationships.add.error.title'), errorContent);
+            this.deselectAndShowError(item1, item2, relationshipType, submissionId, hasNoValue(rd));
           }
+          return rd.hasSucceeded && hasValue(rd.payload) ? rd.payload : undefined;
         }),
       );
   }
 
+  private deselectAndShowError(item1: Item, item2: Item, relationshipType: string, submissionId: string, noMatchFound = false) {
+    const listId = `list-${submissionId}-${relationshipType}`;
+    this.selectableListService.findSelectedByCondition(listId, (object: any) => hasValue(object.indexableObject) && object.indexableObject.uuid === item2.uuid).pipe(
+      take(1),
+      hasValueOperator(),
+    ).subscribe((selected) => {
+      this.selectableListService.deselectSingle(listId, selected);
+    });
+    let errorContent;
+    if (noMatchFound) {
+      errorContent = this.translateService.instant('relationships.add.error.relationship-type.content', { type: relationshipType });
+    } else {
+      errorContent = this.translateService.instant('relationships.add.error.server.content');
+    }
+    this.notificationsService.error(this.translateService.instant('relationships.add.error.title'), errorContent);
+  }
+
+  /**
+   * Perform a "replace" of a metadata value with a new relationship
+   * A replace happens in three steps:
+   *   - The old metadata value is removed with an item PATCH
+   *   - The new relationship is created
+   *   - The relationship's place is updated to fit the old place of the removed metadata value
+   * @param item1             First item in the relationship to create
+   * @param item2             Second item in the relationship to create
+   * @param replaceLeftSide   If true, item1 will have its metadata value replaced, otherwise item2
+   * @param place             The index of the metadata value to replace
+   * @param metadataField     The metadata field of the metadata value to replace
+   * @param section           The submission section of the metadata value to replace
+   * @param relationshipType  The type of relationship
+   * @param submissionId      The ID of the submission this action is taking place in
+   * @param nameVariant       Optional name variant of the to-be-created relationship
+   * @private
+   */
+  private replaceRelationship(item1: Item, item2: Item, replaceLeftSide: boolean, place: number, metadataField: string, section: string, relationshipType: string, submissionId: string, nameVariant?: string) {
+    return this.submissionObjectService.findById(submissionId).pipe(
+      getFirstCompletedRemoteData(),
+      switchMap((rd: RemoteData<SubmissionObject>) => {
+        if (rd.hasSucceeded) {
+          // If the place of the metadata value to replace is missing or -1, pick the last place with the section and field
+          let updatedPlace = place;
+          if (hasNoValue(place) || place < 0) {
+            updatedPlace = rd.payload.sections?.[section]?.[metadataField]?.length - 1;
+          }
+          return this.submissionObjectService.patch(rd.payload, [{ op: 'remove', path: `/sections/${section}/${metadataField}/${updatedPlace}` } as Operation]).pipe(
+            getFirstCompletedRemoteData(),
+            switchMap((patchedRd: RemoteData<SubmissionObject>) => {
+              if (patchedRd.hasSucceeded) {
+                return this.addRelationship(item1, item2, relationshipType, submissionId, nameVariant);
+              } else if (hasValue(patchedRd)) {
+                this.deselectAndShowError(item1, item2, relationshipType, submissionId);
+              }
+              return [undefined];
+            }),
+            switchMap((rel: Relationship) => {
+              if (hasValue(rel)) {
+                const updatedRelationship: Relationship = Object.assign(new Relationship(), rel);
+                if (replaceLeftSide) {
+                  updatedRelationship.leftPlace = updatedPlace;
+                } else {
+                  updatedRelationship.rightPlace = updatedPlace;
+                }
+                return this.relationshipService.update(updatedRelationship).pipe(
+                  getFirstCompletedRemoteData(),
+                );
+              } else {
+                return [undefined];
+              }
+            }),
+          );
+        } else {
+          this.deselectAndShowError(item1, item2, relationshipType, submissionId);
+          return [undefined];
+        }
+      }),
+    );
+  }
+
   private removeRelationship(item1: Item, item2: Item, relationshipType: string) {
     return this.relationshipService.getRelationshipByItemsAndLabel(item1, item2, relationshipType).pipe(
       mergeMap((relationship: Relationship) => this.relationshipService.deleteRelationship(relationship.id, 'none')),
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.spec.ts
index f7b9d7acd15..d8a62744004 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.spec.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.spec.ts
@@ -142,24 +142,20 @@ describe('DsDynamicLookupRelationSearchTabComponent', () => {
 
   describe('selectPage', () => {
     beforeEach(() => {
-      spyOn(component.selectObject, 'emit');
       component.selectPage([searchResult1, searchResult2, searchResult4]);
     });
 
-    it('should emit the page filtered from already selected objects and call select on the service for all objects', () => {
-      expect(component.selectObject.emit).toHaveBeenCalledWith(searchResult4);
+    it('should call select on the service for all objects', () => {
       expect(selectableListService.select).toHaveBeenCalledWith(listID, [searchResult1, searchResult2, searchResult4]);
     });
   });
 
   describe('deselectPage', () => {
     beforeEach(() => {
-      spyOn(component.deselectObject, 'emit');
       component.deselectPage([searchResult1, searchResult2, searchResult3]);
     });
 
-    it('should emit the page filtered from not yet selected objects and call select on the service for all objects', () => {
-      expect((component.deselectObject as any).emit).toHaveBeenCalledWith(searchResult1, searchResult2);
+    it('should call deselect on the service for all objects', () => {
       expect(selectableListService.deselect).toHaveBeenCalledWith(listID, [searchResult1, searchResult2, searchResult3]);
     });
   });
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.ts
index 2562d4c4778..62167714603 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/relation-lookup-modal/search-tab/dynamic-lookup-relation-search-tab.component.ts
@@ -204,12 +204,6 @@ export class DsDynamicLookupRelationSearchTabComponent implements OnInit, OnDest
    * @param page The page to select
    */
   selectPage(page: SearchResult<DSpaceObject>[]) {
-    this.selection$
-      .pipe(take(1))
-      .subscribe((selection: SearchResult<Item>[]) => {
-        const filteredPage: SearchResult<DSpaceObject>[] = page.filter((pageItem: SearchResult<DSpaceObject>) => selection.findIndex((selected: SearchResult<Item>) => selected.equals(pageItem)) < 0);
-        this.selectObject.emit(...filteredPage);
-      });
     this.selectableListService.select(this.listId, page);
   }
 
@@ -219,12 +213,6 @@ export class DsDynamicLookupRelationSearchTabComponent implements OnInit, OnDest
    */
   deselectPage(page: SearchResult<DSpaceObject>[]) {
     this.allSelected = false;
-    this.selection$
-      .pipe(take(1))
-      .subscribe((selection: SearchResult<Item>[]) => {
-        const filteredPage = page.filter((pageItem) => selection.findIndex((selected) => selected.equals(pageItem)) >= 0);
-        this.deselectObject.emit(...filteredPage);
-      });
     this.selectableListService.deselect(this.listId, page);
   }
 
diff --git a/src/app/shared/object-collection/shared/selectable-list-item-control/selectable-list-item-control.component.ts b/src/app/shared/object-collection/shared/selectable-list-item-control/selectable-list-item-control.component.ts
index 3a2fbd30ec9..4352e5f5b2e 100644
--- a/src/app/shared/object-collection/shared/selectable-list-item-control/selectable-list-item-control.component.ts
+++ b/src/app/shared/object-collection/shared/selectable-list-item-control/selectable-list-item-control.component.ts
@@ -9,10 +9,9 @@ import {
 import { FormsModule } from '@angular/forms';
 import { ListableObject } from '@dspace/core/shared/object-collection/listable-object.model';
 import { TranslateModule } from '@ngx-translate/core';
-import { Observable } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
 import {
   map,
-  skip,
   take,
 } from 'rxjs/operators';
 
@@ -50,7 +49,7 @@ export class SelectableListItemControlComponent implements OnInit {
 
   @Output() selectObject: EventEmitter<ListableObject> = new EventEmitter<ListableObject>();
 
-  selected$: Observable<boolean>;
+  selected$: BehaviorSubject<boolean> = new BehaviorSubject(false);
 
   constructor(public selectionService: SelectableListService) {
   }
@@ -59,15 +58,20 @@ export class SelectableListItemControlComponent implements OnInit {
    * Setup the dynamic child component
    */
   ngOnInit(): void {
-    this.selected$ = this.selectionService.isObjectSelected(this.selectionConfig.listId, this.object);
-    this.selected$
-      .pipe(skip(1)).subscribe((selected: boolean) => {
+    let first = true;
+    // TODO in the future this should be refactored because it creates a memory leak, but without it closing the modal
+    //  too early can prevent authors from being added
+    this.selectionService.isObjectSelected(this.selectionConfig.listId, this.object).subscribe((selected: boolean) => {
+      if (!first && this.selected$.value !== selected) {
         if (selected) {
           this.selectObject.emit(this.object);
         } else {
           this.deselectObject.emit(this.object);
         }
-      });
+      }
+      this.selected$.next(selected);
+      first = false;
+    });
   }
 
   selectCheckbox(value: boolean) {
@@ -85,7 +89,7 @@ export class SelectableListItemControlComponent implements OnInit {
         take(1),
         map((selected) => selected ? selected.selection : []),
       ).subscribe((selection) => {
-        // First deselect any existing selections, this is a radio button
+        this.selected$.next(value);// First deselect any existing selections, this is a radio button
         selection.forEach((selectedObject) => {
           this.selectionService.deselectSingle(this.selectionConfig.listId, selectedObject);
           this.deselectObject.emit(selectedObject);
diff --git a/src/app/shared/resource-policies/form/resource-policy-form.component.spec.ts b/src/app/shared/resource-policies/form/resource-policy-form.component.spec.ts
index cb8be1993fa..92b3dfe105b 100644
--- a/src/app/shared/resource-policies/form/resource-policy-form.component.spec.ts
+++ b/src/app/shared/resource-policies/form/resource-policy-form.component.spec.ts
@@ -255,6 +255,7 @@ describe('ResourcePolicyFormComponent test suite', () => {
         provideMockActions(() => new Observable<any>()),
         { provide: LiveRegionService, useValue: getLiveRegionServiceStub() },
         NgbModal,
+        { provide: 'sectionDataProvider', useValue: { id: 'mock-section-id' } },
       ],
       schemas: [
         NO_ERRORS_SCHEMA,
diff --git a/src/app/submission/sections/form/section-form.component.ts b/src/app/submission/sections/form/section-form.component.ts
index b4f1fc399cc..e0005c3c2df 100644
--- a/src/app/submission/sections/form/section-form.component.ts
+++ b/src/app/submission/sections/form/section-form.component.ts
@@ -297,7 +297,7 @@ export class SubmissionSectionFormComponent extends SectionModelComponent implem
       .forEach((key) => {
         diffObj[key].forEach((value) => {
           // the findIndex extra check excludes values already present in the form but in different positions
-          if (value.hasOwnProperty('value') && findIndex(this.formData[key], { value: value.value }) < 0) {
+          if (!value.hasOwnProperty('value') || findIndex(this.formData[key], { value: value.value }) < 0) {
             diffResult.push(value);
           }
         });
diff --git a/src/app/submission/submission-object.service.ts b/src/app/submission/submission-object.service.ts
index 0ccb9496bf2..1288739d965 100644
--- a/src/app/submission/submission-object.service.ts
+++ b/src/app/submission/submission-object.service.ts
@@ -16,6 +16,7 @@ import { SubmissionObject } from '@dspace/core/submission/models/submission-obje
 import { SubmissionScopeType } from '@dspace/core/submission/submission-scope-type';
 import { WorkflowItemDataService } from '@dspace/core/submission/workflowitem-data.service';
 import { WorkspaceitemDataService } from '@dspace/core/submission/workspaceitem-data.service';
+import { Operation } from 'fast-json-patch';
 import {
   Observable,
   of,
@@ -98,4 +99,25 @@ export class SubmissionObjectService {
       }
     }
   }
+
+  patch(object: SubmissionObject, operations: Operation[]): Observable<RemoteData<SubmissionObject>> {
+    switch (this.submissionService.getSubmissionScope()) {
+      case SubmissionScopeType.WorkspaceItem:
+        return this.workspaceitemDataService.patch(object, operations);
+      case SubmissionScopeType.WorkflowItem:
+        return this.workflowItemDataService.patch(object, operations);
+      default: {
+        const now = new Date().getTime();
+        return of(new RemoteData(
+          now,
+          this.appConfig.cache.msToLive.default,
+          now,
+          RequestEntryState.Error,
+          'The request could not be sent. Unable to determine the type of submission object',
+          undefined,
+          400,
+        ));
+      }
+    }
+  }
 }