Python 3.8 (pre-release), 75 74 71 bytes

-1 bytes thanks to @EmbodimentofIgnorance

-3 bytes thanks to @xnor

This takes Knuts, Sickles, and Galleons as ints, interest as a float (decimal, not percentage), and years as an int. It returns a tuple containing the number after interest of Knuts, Sickles, and Galleons, respectively.

lambda K,S,G,R,Y:((k:=int((K+G*493+S*29)*(1+R)**Y))%29,k//29%17,k//493)

Usage:

>>> print(I(23,16,103,0.0725,3))

(24, 4, 128)

Try it online!

APL+WIN, 37 28 26 bytes

⌊a⊤((a←0 17 29)⊥⎕)×(1+⎕)*⎕

2 bytes saved thanks to lirtosiast

Try it online! Courtesy of Dyalog Classic

Explanation:

(1+⎕)*⎕ prompts for years followed by decimal interest rate and calculates

         compounding multiplier



((a←0 17 29)⊥⎕) prompts for Galleons, Sickles and Knuts and converts to Knuts



⌊a⊤ converts back to Galleons, Sickles and Knuts and floor 

    after applying compound interest. 

R, 70 bytes

function(d,i,y,m=sum(d*(a=c(1,29,493))))(m*(1+i)^y)%/%a%%c(29,17,1e99)

Try it online!

Takes input as d: deposit in knuts, sickles, galleons; i: interest rate as decimal; y: years. Outputs final deposit in knuts, sickles, galleons. Galleons would wrap round at 1e99 which I hope is acceptable.

Perl 6, 47 bytes

((1+*)*** *(*Z*1,29,493).sum+|0).polymod(29,17)

Try it online!

I'm surprised I managed to get this into an anonymous Whatever lambda! Especially the part where it's more *s than anything else. Takes input as interest rate (e.g. 0.0725), years, [Knuts, Sickles, Galleons] and returns a list of currencies in the same order.

Explanation:

 (1+*)           # Add one to the interest rate

      ***        # Raise to the power of the year

          *      # And multiply by

           (*Z*1,29,493).sum      # The number of Knuts in the input

                            +|0   # And floor it

(                              ).polymod(29,17)   # Get the modulos after divmoding by 29 and 17

Jelly, 29 bytes

“¢×ø‘©×

÷ȷ2‘*⁵×÷¢S×¢d®U1¦Ṫ€Ḟ

A full program accepting arguments: rate; [Galleons, Sickles, Knuts]; years.

Prints [Galleons, Sickles, Knuts].

Try it online!

Floors at the end of the entire term.
÷ȷ2 may be removed if we may accept the rate as a ratio rather than a percentage.

How?

“¢×ø‘©× - Link 1 multipliers: no arguments

“¢×ø‘    - list of code-age indices = [1,17,29]

     ©   - (copy this to the register for later use)

        - reduce by:

      ×  -   multiplication  = [1,17,493]



÷ȷ2‘*⁵×÷¢S×¢d®U1¦Ṫ€Ḟ - Main Link

 ȷ2                  - 10^2 = 100

÷                    - divide = rate/100

   ‘                 - increment = 1+rate/100

     ⁵               - 5th command line argument (3rd input) = years

    *                - exponentiate = (1+rate/100)^years --i.e. multiplicand

      ×              - multiply (by the borrowed amounts)

        ¢            - call last Link as a nilad

       ÷             - divide (all amounts in Galleons)

         S           - sum (total Galleons owed)

           ¢         - call last Link as a nilad

          ×          - multiply (total owed in each of Galleons, Sickles, Knuts)

             ®       - recall from register = [1,17,29]

            d        - divmod (vectorises) = [[G/1, G%1], [S/17, S^17], [K/17, K%17]]

              U1¦    - reverse first one = [[G%1, G/1], [S/17, S%17], [K/17, K%17]]

                 Ṫ€  - tail €ach = [G/1, S%17, K%17]

                   Ḟ - floor (vectorises)

K, 46 Bytes

c:1000 17 29

t:{c:{z(y*)/x}[c/:x;1+y%100;z]}

c store the list for base-conversion

t is the function that calculates total amount

Use example:

t[103 16 23;7.25;3]

writes (128;4;24.29209)

Explanation:

• c/:x transform the list (galleon; sickle; knuts) to kuts




• 1+y%100 calculate rate of interest (example 1.0725 for 7.25% rate)




• lambda {z(y*)x} does the work: iterate 3 times, applying interes*main, and returns final main.




• c: generates galleon, sickles, knuts from knuts

NOTE.- if you don't need a names-function, we can use a lambda, saving 2 bytes
{c:{z(y*)/x}[c/:x;1+y%100;z]}inputArgs

C# (Visual C# Interactive Compiler), 86 bytes

(a,b,c)=>((k=(int)((a.a*493+a.b*29+a.c)*Math.Pow(1+b,c)))/493,(k%=493)/29,k%29);int k;

Takes inout as a named tuple with 3 values representing knuts, sickles, and galleons, and interest rate as a double (not a percentage). I really wish C# had an exponentation operator. Math.Pow is way too long :(

Try it online!

Japt, 48 bytes

XÄ pY *(U*493+V*29+W)f

Uu493

[Uz493 ,Vz29 ,Vu29]

My first try at Japt, going for @Shaggy's bounty! Needless to say, this isn't very golfy :(

Try it Online!

Batch, 171 bytes

@set i=%4

@set/af=0,i=8*%i:.=,f=%,f*=8

@set/ai+=%f:~,1%,k=%1*493+%2*29+%3

@for /l %%y in (1,1,%5)do @set/ak+=k*i/800

@set/ag=k/493,s=k/29%%17,k%%=29

@echo %g% %s% %k%

Takes input as command-line arguments in the order Galleons, Sickles, Knuts, interest, years. Interest is a percentage but expressed without the % sign. Truncates after every year. Output is in the order Galleons, Sickles, Knuts. Supports at least 5000 Galleons. Explanation:

@set i=%4

@set/af=0,i=8*%i:.=,f=%,f*=8

Batch only has integer arithmetic. Fortunately, the interest rate is always a multiple of 0.125. We start by splitting on the decimal point, so that i becomes the integer part of the interest rate and f the decimal fraction. These are then multiplied by 8. The first digit of f is now the number of eighths in the percentage interest rate.

@set/ai+=%f:~,1%,k=%1*493+%2*29+%3

This is then extracted using string slicing and added on to give an interest rate in 1/800ths. The number of Knuts is also calculated.

@for /l %%y in (1,1,%5)do @set/ak+=k*i/800

Calculate and add on each year's interest.

@set/ag=k/493,s=k/29%%17,k%%=29

@echo %g% %s% %k%

Convert back to Galleons and Sickles.