anchor.diff:                  true ->
                       lists:max([LP, RP]);
                   false ->
  -                    ChooseLeft = case RClock =:= LClock of
  -                                     true ->
  -                                         LV < RV;
  -                                     false ->
  -                                         vclock:likely_newer(LClock, RClock)
  -                                 end,
  -                    V = case ChooseLeft of
  -                            true ->
  +                    V = case {vclock:likely_newer(LClock, RClock),
  +                              vclock:likely_newer(RClock, LClock)} of
  +                            {X1, X1} ->
  +                                [Winner, Loser] = lists:sort([LV, RV]),
  +
  +                                ?user_log(?CONFIG_CONFLICT,
  +                                          "Conflicting configuration changes to field "
  +                                          "~p:~n~p and~n~p, choosing the former.~n",
  +                                          [K,
  +                                           ns_config_log:sanitize(Winner),
  +                                           ns_config_log:sanitize(Loser)]),
  +
  +                                Winner;
  +                            {LocalNewer, RemoteNewer} ->
  +                                true = LocalNewer xor RemoteNewer,
  +
  +                                [Winner, Loser] =
  +                                    case LocalNewer of
  +                                        true ->
  +                                            [LV, RV];
  +                                        false ->
  +                                            [RV, LV]
  +                                    end,
  +
                                   ?user_log(?CONFIG_CONFLICT,
                                             "Conflicting configuration changes to field "
                                             "~p:~n~p and~n~p, choosing the former, which looks newer.~n",
                                             [K,
  -                                           ns_config_log:sanitize(LV),
  -                                           ns_config_log:sanitize(RV)]),
  -                                LV;
  -                            false ->
  -                                ?user_log(?CONFIG_CONFLICT,
  -                                          "Conflicting configuration changes to field "
  -                                          "~p:~n~p and~n~p, choosing the former.~n",
  -                                          [K,
  -                                           ns_config_log:sanitize(RV),
  -                                           ns_config_log:sanitize(LV)]),
  -                                RV
  +                                           ns_config_log:sanitize(Winner),
  +                                           ns_config_log:sanitize(Loser)]),
  +
  +                                Winner
                           end,
  +
                       %% Increment the merged vclock so we don't pingpong
  -                    {K, increment_vclock(V, merge_vclocks(RV, LV))}
  +                    {K, increment_vclock(V, merge_vclocks(RV, LV), Node)}
               end;
           {true, false} -> RP;
           {false, true} -> LP
  
positive.code: 
  %% Increment the vclock in V2 and replace the one in V1
  increment_vclock(NewValue, OldValue) ->
      OldVClock = extract_vclock(OldValue),
      NewVClock = lists:sort(vclock:increment(node(), OldVClock)),
      [{?METADATA_VCLOCK, NewVClock} | strip_metadata(NewValue)].
  
  %% Set the vclock in NewValue to one that descends from both
  
negative.code:     misc:ukeymergewith(Merger, 1, RemoteKVList1, LocalKVList1).
  
  -spec merge_values({term(), term()}, {term(), term()}) -> {term(), term()}.
  merge_values(RP, LP) ->
      do_merge_values(RP, LP, node()).
  
  do_merge_values({_K, RV} = RP, {_, LV} = _LP, _Node) when RV =:= LV -> RP;
  do_merge_values({K, RV} = RP, {_, LV} = LP, Node) ->
      RClock = extract_vclock(RV),
      LClock = extract_vclock(LV),
      case {vclock:descends(RClock, LClock),
  