Are macros lazily evaluated?

I am watching this talk by Jesse Anderson at ElixirConf about how macros work. He creates a macro (if statement), then contrasts it with a functional example.

Macro Version:

defmodule MyMacros do
  defmacro my_if(condition, do: do_clause, else: else_clause) do
    quote do
      case unquote(condition) do
        true -> unquote(do_clause)
        false -> unquote(else_clause)
      end
    end
  end
end

Function version:

defmodule MyFunctions do
  def my_if(condition, do: do_clause, else: else_clause) do
     case condition do
        true -> do_clause
        false -> else_clause
      end
   end
end

If you were to call my_if 1 + 2 == 3, do: "this", else: "that", you get the same result from either module. But if evaluation order matters in the do/else blocks, the behavior is different.

iex(17)> MyMacros.my_if 1 + 2 == 3, do: IO.puts("this"), else: IO.puts("that")
this
:ok
iex(18)> MyFunctions.my_if 1 + 2 == 3, do: IO.puts("this"), else: IO.puts("that")
this
that
:ok

Is this considered an example of lazy evaluation, or is this deferred evaluation typically described some other way?