I found the course to the issue.

When the controller Our.Umbraco.DocTypeGridEditor.Dialogs.DocTypeGridEditorDialog is calling the function submit. The function use contentEditingHelper.contentEditorPerformSave(args).

// save the content as a blueprint, to trigger validation
var args = {
    saveMethod: contentResource.saveBlueprint,
    scope: $scope,
    content: $scope.model.node,
    create: true,
    action: "save",
    showNotifications: false,
    softRedirect: true
}

The contentEditingHelper method contentEditorPerformSave is updating the editorState with editorState.set(args.content) which leads to wrong editorState data for everything that is using the editorState service.

contentEditorPerformSave: function (args) {
            if (!Utilities.isObject(args)) {
                throw "args must be an object";
            }
            if (!args.scope) {
                throw "args.scope is not defined";
            }
            if (!args.content) {
                throw "args.content is not defined";
            }
            if (!args.saveMethod) {
                throw "args.saveMethod is not defined";
            }
            if (args.showNotifications === undefined) {
                args.showNotifications = true;
            }
            // needed for infinite editing to create new items
            if (args.create === undefined) {
                if ($routeParams.create) {
                    args.create = true;
                }
            }
            if (args.softRedirect === undefined) {
                //when true, the url will change but it won't actually re-route
                //this is merely here for compatibility, if only the content/media/members used this service we'd prob be ok but tons of editors
                //use this service unfortunately and probably packages too.
                args.softRedirect = false;
            }


            var self = this;

            //we will use the default one for content if not specified
            var rebindCallback = args.rebindCallback === undefined ? self.reBindChangedProperties : args.rebindCallback;

            var formSubmitOptions = { scope: args.scope, action: args.action };
            if(args.skipValidation === true) {
                formSubmitOptions.skipValidation = true;
                formSubmitOptions.keepServerValidation = true;
            }
            if (formHelper.submitForm(formSubmitOptions)) {

                return args.saveMethod(args.content, args.create, fileManager.getFiles(), args.showNotifications)
                    .then(function (data) {

                        formHelper.resetForm({ scope: args.scope });

                        if (!args.infiniteMode) {
                            self.handleSuccessfulSave({
                                scope: args.scope,
                                savedContent: data,
                                softRedirect: args.softRedirect,
                                rebindCallback: function () {
                                    rebindCallback.apply(self, [args.content, data]);
                                }
                            });

                            //update editor state to what is current
                            editorState.set(args.content);
                        }

                        return $q.resolve(data);

                    }, function (err) {

                        formHelper.resetForm({ scope: args.scope, hasErrors: true });

                        self.handleSaveError({
                            showNotifications: args.showNotifications,
                            softRedirect: args.softRedirect,
                            err: err,
                            action: args.action,
                            rebindCallback: function () {
                                // if the error contains data, we want to map that back as we want to continue editing this save. Especially important when the content is new as the returned data will contain ID etc.
                                if(err.data) {
                                    rebindCallback.apply(self, [args.content, err.data]);
                                }
                            }
                        });

                        //update editor state to what is current
                        editorState.set(args.content);

                        //needs to be manually set for infinite editing mode
                        args.scope.isNew = args.content.id === 0 && args.scope.isNew;

                        return $q.reject(err);
                    });
            }
            else {
                return $q.reject();
            }

        }

Could DTGE trigger a validation another way?