How do I stop the Compositor Output Node from overwriting my images on each new render? Using the compositor node setup above, when I hit F12, it makes a new pass and the rendered images are automatically saved. The problem is that the new render erases the previous one that was saved in my folder.

How can I prevent this?

I've already unchecked the "overwrite" option in the output panel in the properties editor, I did not see any similar options in the compositor editor.

I just want Blender to create a "render01" if a render is already there, exactly like in the outliner!
Thinking ahead, you want the Output Path in sync with all the File Output Nodes of the compositor. 

I think one easy way to solve this is adding a 'version number' to all output paths (as usual) and keep all file names in sync. Here is a quick'n dirty Add-on to address that. Once you add v and some arbitrary number to the Output Path, a new 'slider' appears in the Output Area, which allows to change the actual version string on the fly. 



render_version.py

# ##### BEGIN GPL LICENSE BLOCK #####
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

bl_info = {
    "name": "Render Version",
    "description": "Output version number control",
    "author": "p2or",
    "version": (0, 0, 2),
    "blender": (2, 80, 0),
    "location": "Properties &gt; Output &gt; Render Version",
    "warning": "", # used for warning icon and text in addons panel
    "wiki_url": "",
    "tracker_url": "",
    "category": "Render"
}

import bpy
import os
import re
from sys import platform
import webbrowser


# ------------------------------------------------------------------------
#    Scene Properties
# ------------------------------------------------------------------------

def rv_update(self, context):
    context.area.tag_redraw()
    scene = context.scene
    render = scene.render

    # Replace the render path
    render.filepath = version_number(
            render.filepath, 
            scene.rv.rdr_ver
        )

    # Replace file output
    if not scene.render.use_compositing or \
        not scene.rv.sync_comp or \
        not scene.node_tree:
        return

    nodes = scene.node_tree.nodes
    output_nodes = [n for n in nodes if n.type=='OUTPUT_FILE']

    for out_node in output_nodes:
        if "LAYER" in out_node.format.file_format:
            out_node.base_path = version_number(
                out_node.base_path, 
                scene.rv.rdr_ver)
        else:
            for out_file in out_node.file_slots:
                out_file.path = version_number(
                    out_file.path, 
                    scene.rv.rdr_ver)
    return None


class RVSettings(bpy.types.PropertyGroup):

    rdr_ver : bpy.props.IntProperty(
        name = "Render Version",
        description="Render Version",
        default = 1, 
        min = 1,
        update = rv_update)

    sync_comp : bpy.props.BoolProperty(
        name = "Sync Compositor",
        description="Sync version string with File Output nodes",
        default = True)

# ------------------------------------------------------------------------
#    Operators
# ------------------------------------------------------------------------

class RVOpenOutputDirectory(bpy.types.Operator):
    """Open up Output Directory in File Browser"""
    bl_idname = "rv.output_directory"
    bl_label = "Open Output Directory in File Browser"
    bl_description = "Output Directory"
    bl_options = {'INTERNAL'}

    def execute(self, context):
        fp = os.path.dirname(context.scene.render.frame_path())
        try:
            if platform.startswith('darwin'):
                webbrowser.open("file://{}".format(fp))
            else:
                webbrowser.open(fp)
        except OSError:
            self.report({'INFO'}, "No Folder")
        return {'FINISHED'}


class RVOutNodesCleanup(bpy.types.Operator):
    """Remove version strings from File Output Nodes"""
    bl_idname = "rv.remove_version_strings"
    bl_label = "Remove Version Strings from File Output Nodes"
    bl_options = {'REGISTER', 'UNDO'}

    @classmethod
    def poll(cls, context):
        space = context.space_data
        return space.type == 'NODE_EDITOR'

    def remove_version(self, fpath):
        match = re.search(r'(v\d+)', fpath)
        delimiters = ("-", "_", ".")
        if match:
            head, tail = fpath.split(match.group(0))
            if tail.startswith(delimiters):
                tail = tail[1:]
            fpath = head + tail
            return fpath[:-1] if fpath.endswith(delimiters) else fpath
        else:
            return fpath

    def execute(self, context):
        scene = context.scene    
        nodes = scene.node_tree.nodes
        output_nodes = [n for n in nodes if n.type=='OUTPUT_FILE']

        if not output_nodes:
            self.report({'INFO'}, "Nothing to operate on")
            return {'CANCELLED'}

        for out_node in output_nodes:
            if "LAYER" in out_node.format.file_format:
                out_node.base_path = self.remove_version(out_node.base_path)
                for layer in out_node.layer_slots:
                    layer.name = self.remove_version(layer.name)
            else:
                out_node.base_path = self.remove_version(out_node.base_path)
                for out_file in out_node.file_slots:
                    out_file.path = self.remove_version(out_file.path)

            scene.rv.sync_comp=False
        return {'FINISHED'}


# ------------------------------------------------------------------------
#    Drawing
# ------------------------------------------------------------------------

def draw_rv(self, context):
    """Append Properties and Operators to the Output Area"""
    rv = context.scene.rv
    if re.search("v\d+", context.scene.render.filepath) is not None:
        layout = self.layout
        #col = layout.column()
        row = layout.row(align=True)
        row.prop(rv, "rdr_ver") #NODE_COMPOSITING
        row.prop(rv, "sync_comp", text="", toggle=True, icon="IMAGE_RGB_ALPHA") 
        row.operator(RVOpenOutputDirectory.bl_idname, icon="DISK_DRIVE", text="")


# ------------------------------------------------------------------------
#    Helper
# ------------------------------------------------------------------------

def version_number(file_path, number, delimiter="_", min_lead=2):
    """Replace or add a version string by given number"""

    match = re.search(r'v(\d+)', file_path)
    if match:
        g = match.group(1)
        n = str(int(number)).zfill(len(g))
        return file_path.replace(match.group(0), "v{v}".format(v=n))

    else:
        lead_zeros = str(int(number)).zfill(min_lead)
        version = "{dl}v{lz}{dl}".format(dl=delimiter, lz=lead_zeros)
        ext = (".png",".jpg",".jpeg","jpg",".exr",".dpx",".tga",".tif",".tiff",".cin")

        if "#" in file_path:
            dash = file_path.find("#")
            head, tail = file_path[:dash], file_path[dash:]
            if head.endswith(delimiter):
                head = head.rstrip(delimiter)
            return "{h}{v}{t}".format(h=head, v=version, t=tail)

        elif file_path.endswith(ext):
            head, extension = os.path.splitext(file_path)
            if head.endswith(delimiter):
                head = head.rstrip(delimiter)
            return "{fp}{v}{ex}".format(fp=head, v=version[:-1], ex=extension)

        else:
            if file_path.endswith(delimiter):
                file_path = file_path.rstrip(delimiter)
            return "{fp}{v}".format(fp=file_path, v=version)


# ------------------------------------------------------------------------
#    Registration
# ------------------------------------------------------------------------

classes = (
    RVSettings,
    RVOpenOutputDirectory,
    RVOutNodesCleanup,
)

def register():
    from bpy.utils import register_class
    for cls in classes:
        register_class(cls)

    bpy.types.Scene.rv = bpy.props.PointerProperty(type=RVSettings)
    bpy.types.RENDER_PT_output.append(draw_rv)


def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)

    bpy.types.RENDER_PT_output.remove(draw_rv)
    del bpy.types.Scene.rv

if __name__ == "__main__":
    register()


Gist: https://gist.github.com/p2or/cff74514f467034a03177871dbc8912b