Q:

Is duplication of declarations still a problem in C++?

Okay so I recently learned how the compiler exactly works and what the "linker" is. From the tutorial videos I've watched I clearly saw that if I include more than once a declaration, to say: 
void Log(const char* message); 

I would get an error since I am declaring it more than once. But currently, as I am testing it, I've created a header file which contains that particular declaration and I've included it a couple of times in my Main compilation unit, as so:
#include "Log.h"
#include "Log.h"

I have removed the #pragma once statement, nor do I have header guards written, but my program still runs perfectly and without any problems. Since the videos are 2-3 years old, I thought maybe there has been an update, which alltogether removes the need of guards and pragmas, but I do not know for sure.

A:

The tutorials you've seen are correct.  You cannot have more than one definition of something unless you use special techniques.
In this case though you don't have a definition.
void Log(const char* message); 

is a declaration and you are allowed to have multiples of those.  If you change the code to
void Log(const char* message) {}

then you would have a function definition and will get an error.

A:

I would get an error since I am declaring it more than once.

Re-declaration is generally allowed, as long as you don't mix different kinds of declarations with the same name. Following is perfectly legal C++, and always has been:
void Log(const char* message); 
void Log(const char* message);

You may have been confused with the one definition rule, which disallows defining things more than once.

I have removed the #pragma once statement, nor do I have header guards written, but my program still runs perfectly and without any problems.

If your header doesn't define anything, then it doesn't need a header guard. It's however simpler to just conventionally always keep the guard so that there is no need to keep track of whether there are definitions or not.

Bonus answer: All definitions are also declarations. It is usually easy to distinguish definitions of classes and functions from forward declarations:
return_type function_name(argument_list);        // not a definition of function
return_type function_name(argument_list) { ... } // is  a definition of function

class class_name;                                // not a definition of class
class class_name {                               // is  a definition of class
    void member_function();                      // not a definition of function
    void inline_member_function() { ... };       // is  a definition of function
};
void class_name::member_function() { ... }       // is  a definition of function

Distinguishing variable definitions is a bit harder. Always check the rules when unsure.

