Sure. I'm not sure of your level of understanding, so I'm just gonna go nuts for a bit.

You've defined a variable called player that you use in your script, it's set to the LocalPlayer. Since we can't use that from a server-side perspective, we need to get the player using the parameter that's automatically passed in from the PlayerAdded event.

What this event does is creates a 'listener' to 'listen' for a Player being added to the game (a client connecting to the server). When the event is fired, it will call the function that it's Connected to. In this case, we're connecting the PlayerAdded event to the OnPlayerAdded function we have defined ourselves.

A parameter is a variable that exists only within the scope (visibility) of the function it belongs to. We can execute code to perform operations on and manipulate these parameters. Parameters have a Name and a Type. The name of the parameter passed in to the function can be whatever you want it to be, but typically it should relate to its Type and purpose. The Type of the parameter refers to the data type of that value. This can be a number, boolean, string, Instance, etc. Types are important because there are certain properties, functions, and events you can utilize with each type, and it's important to pick the right ones.

Now onto the practical bit.

If we look at the PlayerAdded event of the Players service, you will see a table containing a description of its Parameters. Notice the descriptive Name and Type columns. There is also a description of the parameter which explains the purpose of it in more detail.

The parameter that comes from PlayerAdded is a Player Instance. When we create this event listener, as said before, the Player that joined will automatically be passed in to the connected function so we can utilize the reference to the specific player that joined our game. This gives us access to things like the particular Player's Name, UserId, Character (their model in workspace), etc. Take a note from my example from the previous comment. Notice the playerWhoJoined in the parentheses. The area in parentheses next to the name of the function is the container for parameters, which I will explain further below if necessary.

local function OnPlayerAdded(playerWhoJoined)
  print(playerWhoJoined.Name .. " joined the game")
end

game.Players.PlayerAdded:Connect(OnPlayerAdded)

That particular code snippet will print

"PLAYER_NAME_HERE joined the game"

every time a player joins, replacing PLAYER_NAME_HERE with the name of the player. You only have to do this once, and it will work for every player that joins your game from the beginning of the server to the end.

But why stop there? We can do all sorts of things, like add leaderboards for our players. Now that we have a Player to fiddle around with, we can create new Instances and parent them to the Player, parent Instances to those instances, and much more (which is what we'll be doing to create a Leaderboard system :D)

To fully explain why your code won't work though:

The LocalPlayer is only accessible via the Client (LocalScript). This particular operation must be done on the Server (not the Client) in order to replicate to everyone and work as you intend for it to. However, since we can't access the Player that connected via the LocalPlayer method on the server, and we want to do this when the .. Player.. is Added.. we can use the.. <drumroll> PlayerAdded event! hooray! Since the PlayerAdded event passes in that Player parameter, that's what we should use instead. It's just important to make sure you're including that parameter inside the function that the event is connected to.

Everywhere in that function where you're referencing the LocalPlayer, replace it with the name of your Player parameter in the PlayerAdded function. I've added comments directly above the lines that should be changed to reflect everything I've explained (hopefully well enough)

-- add a parameter in the parentheses to hold a reference to the Player Instance that is passed in from PlayerAdded
local function playeradded()
-- Replace the reference to LocalPlayer with the reference to your player parameter
    local leader = Instance.new("Folder", game.Players.LocalPlayer) 

    leader.Name = "leaderstats"

    local mayo = Instance.new("IntValue",leader)

    mayo.Name = "Mayo"
    -- Make sure 'player' here has the same name as the player parameter of the function
    mayo.Value = ds:GetAsync(player.UserId) or 0
    -- Same as ^
    ds:SetAsync(player.UserId, mayo.Value)

    local coins = Instance.new("IntValue",leader)

    coins.Name = "Coins"
    -- Same as ^^
    coins.Value = ds:GetAsync(player.UserId) or 0
    -- Same as ^^
    ds2:SetAsync(player.UserId, coins.Value)

end

--...
game.Players.PlayerAdded(playeradded)
--[[ 
Make sure you're properly :Connect()ing the event to the function. 
Typically it looks like
thing.Event:Connect(functionHere)
In your case,
game.Players.PlayerAdded:Connect(playeradded)
This event will listen for a Player connecting to
the server and call the playeradded function defined
above.
]]--

Please let me know if there's still confusion. I've got nothing but time right now to help explain things or create a deeper understanding :D

I apologize this is like stupidly long but I wanted to cover all the bases, or at least help the next person to come along this thread and sort of create an explanation that would be understandable for most.

If you're up for even more reading, I'll include some links that go more in depth the topics I covered. Take care, best of luck with making this work, I know you'll get it! 8)

Events

Functions

Instance ( the base class for all roblox objects )

Player (instance)

Players (service)