
<p class="has-drop-cap">1 Idag är det sista chansen att kvala in till Prix d’Amérique, men det finns också möjlighet att ta sig vidare på intjänade prispengar i karriären – två platser innan dagens Prix de Belgique (€120.000) – och de hästar som ligger bäst till i dagsläget är <strong>Ampia Mede Sm</strong> (€1.566.696) och <strong>Don Fanucci Zet </strong>(€1.521.836) sedan Philippe Allaire bestämt sig för att stå över Prix d&#8217;Amérique med <strong>Hohneck</strong> (€2.527.145). </p>



<p>Både Ampia Mede Sm (e. Ganymede) och Don Fanucci Zet (e. Hard Livin) startar i Prix de Belgique (€120.000) och båda hästarna kan ta loppet som en uppmjukning inför Prix d’Amérique (€1.000.000) den 26 januari på Vincennes.</p>



<p>– Don Fanucci Zet fick gå ett tuffare träningspass i onsdags och kändes bra. Han fick ett omöjligt lopp senast, men något störde honom den dagen. Han var inte lika allert i värmningen som innan och dagen efter sprack det upp som en liten böld från ena benet, så troligen jobbade kroppen med något annat den dagen. Vi tar omtag nu på söndag, det blir ett snällt upplägg denna start, skriver Daniel Redén på sin blogg.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/07/misterherculeskm200721adamstrmstalltz-617x416.jpg" alt="" class="wp-image-101603"/><figcaption class="wp-element-caption">Mister Hercules. Foto: Adam Ström/stalltz.se
</figcaption></figure>



<p>Daniel Redén startar också <strong>Mister Hercules</strong> (e. Muscle Hill), vilken slutade oplacerad i Prix de Bourgogne. Till skillnad mot Don Fanucci Zet behöver han ta en plats bland de fyra främsta för att kvala in till Prix d&#8217;Amérique.</p>



<p>– Mister Hercules kan vara en riktig luring på söndag…. Höll på att gå i backen i en tajt situation i sista sväng senast med alla växlar kvar. Joggade sedan bara i mål efter fältet med sträckta linor. Får han ett smyglopp kan han kvala in till Prix d’Amérique. Vi lever på hoppet!</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">2 Är det ett bra omen att vinna Prix de Belgique? Inte alls…vinn Prix d’Belgique och du förlorar Prix d’Amérique! Ja, så har faktiskt varit fallet för 24 av de 25 Prix de Belgique-vinnarna under 2000-talet.</p>



<p>Enda hästen som lyckats vinna det sista B-loppet och sedan följa upp med triumf i Prix d’Amérique under den nämnda perioden är <strong>Bold Eagle</strong> (e. Ready Cash) och det skedde 2016.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/11/queenl.heat-617x333.jpg" alt="" class="wp-image-245467"/><figcaption class="wp-element-caption">Queen L. och Stig H Johansson. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p>Innan Bold Eagle var det Stig H Johansson och <strong>Queen L</strong>, som klarade av detta 1993. Två år tidigare gjorde <strong>Tenor de Baune</strong> samma sak, fenomenet <strong>Ourasi </strong>vid tre tillfällen (1986, 1987 och 1988) och <strong>Lurabo </strong>1984. </p>



<p>Sedan får vi gå tillbaka till <strong>Belino II</strong> 1976 och innan det året avgjordes inte Prix de Belgique två veckor innan Prix d’Amérique utan i december och är således inte jämförbart på samma sätt.</p>



<p>15 hästar tar chansen idag på <strong>Vincennes </strong>(första start kl. 13.23) att försöka kvala in till Prix d’Amérique och nedan hittar du startlistan till dagens lopp.</p>



<h2 class="wp-block-heading">Startlista: </h2>



<p><strong>Prix de Belgique</strong> (€120.000)<br>4-11 år.<br><strong>Priser:</strong> 54.000-30.000-16.800-9.600-6.000-2.400-1.200 euro.<br><em>2.850 meter.</em></p>



<p><strong>Namn (far) – Kusk/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Iroise de la Noe</strong> (e. Tornado Bello) – Thomas Levesque</li>



<li><strong>Happy Danica </strong>(e. Briac Dark) – Alexis Garandeau</li>



<li><strong>Harley Gema</strong> (e. Bold Eagle) – Benjamin Rochard/Marc Sassier</li>



<li><strong>J’Aime Le Foot </strong>(e. Boccador de Simm) – Antoine Lherete</li>



<li><strong>Junionho Dry </strong>(e. Carat Williams) – Paul-Philippe Ploquin/Sébastian Guarato</li>



<li><strong>Justin Bold</strong> (e. Bold Eagle) – Pierre Yves-Verva/Jean-Rémi Delliaux</li>



<li><strong>Ideal Ligneries</strong> (e. Repeat Love) – Jean-Philippe Monclin</li>



<li><strong>It’s A Dollarmaker </strong>(e. Saxo de Vandel) – Matthieu Abrivard/Sébastien Guarato</li>



<li><strong>Mister Hercules</strong> (e. Trixton) – Francois Lagadeuc/Daniel Redén</li>



<li><strong>Happy and Lucky</strong> (e. Ready Cash) – Adrien Lamy/Franck Leblanc</li>



<li><strong>Just Love You</strong> (e. Love You) – Alexandre Abrivard/Laurent-Claude Abrivard</li>



<li><strong>Inmarosa</strong> (e. Amiral Sacha) – Léo Abrivard/Laurent-Claude Abrivard</li>



<li><strong>Don Fanucci Zet</strong> (e. Hard Livin) – Jean-Michel Bazire/Daniel Redén</li>



<li><strong>Ampia Mede Sm</strong> (e. Ganymede) – Vincenzo Alessandro Jr./Erik Bondo</li>



<li><strong>Hooker Berry </strong>(e. Booster Winner) – Nicolas Bazire</li>
</ol>



<p><strong>Nedan du Paris-Turf ranking till Prix de Belgique: </strong></p>



<p>8-1-15-12-7-13 (Don Fanucci Zet)-9 (Mister Hercules)-14-3-2-5-11-6-4-10</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3 Flera penningstinna lopp är det på <strong>Vincennes </strong>(kl. 13.23) idag, men det är tunt med svensktränade- och -födda hästar förutom Daniel Redéns <strong>Don Fanucci Zet </strong>och <strong>Mister Hercules</strong>. </p>



<p>I ett lopp för europafödda sjuåringar – Prix de Toulouse (€46.000) – sitter Michael Nimczyk upp bakom svenskfödda och årsdebuterande <strong>Sangria Pellini</strong> (e. Chocolatier). Distansen är 2.100 meter autostart och förstapriset uppgår till 20.700 euro.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-01-12/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-01-12/" target="_blank" rel="noreferrer noopener">Här hittar ni samtliga startlistor till dagens tävlingar på Vincennes.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">42,6 miljoner kronor extra ligger i potten i eftermiddagens Grand Slam 75-omgång på <strong>Umåker</strong> (första start 13.45). Till. skillnad från de övriga streckspelen delas nämligen jackpotpengar ut i alla vinstpooler på GS75.<br>För Umåker är det årets första av 18 tävlingsdagar, där höjdpunkterna är V75-dagen den 10 maj med Berth Johanssons Memorial och juldagens traditionella tävlingar.</p>



<p>Dagens årspremiär då? Janita Luttunen blev Bodentränare förra sommaren och har visat god form på stallets hästar i vinter. <strong>Black Luca</strong> (e. Brad de Veluwe) vann inom Umåkers V75-omgång på juldagen och är nu tillbaka för ett nytt gästspel i Västerbotten. Jens Eriksson sitter i sulkyn den här gången bakom femåringen som dragit innerspår bakom bilen.</p>



<p>Utanför streckspelet gör segermaskinen <strong>Cool Trix</strong> (e. Trixton) fjärde starten i Ann-Catrin Frisks regi. Efter seger i debuten har det blivit en femteplats som bäst i V75-sammanhang efteråt.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/01/12gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">5 Daniel Redéns uppfödning <strong>Madagascar</strong> (e. Father Patrick) såldes till Finland på Traveras auktion i oktober 2023 och hästen fann sig väl tillrätta i sitt nya hemland i regi Anne Kangas. Förra året blev det fem segrar och ytterligare fyra pallplatser på tolv starter, men det nya året har börjat ännu bättre.</p>



<p>Igår på Vermo tog hästen andra raka segern under 2025 när han ledde från start till mål och vann enkelt på 1.13,0a/1.620 meter tillsammans med Santtu Raitala. Segern var värd 4.000 euro och totalt har Madagascar sprungit in drygt 57.000 euro efter tio segrar på 28 starter.</p>



<p>Ännu vassare segerform visar svenskfödda <strong>Red Rose</strong> (e. Muscle Mass) upp. Fjärde raka segern och ytterligare 4.000 euro i prispengar räknades in på Vermo igår. Raitala satt i vagnen bakom det svenskägda stoet som tränas av Marinka Salminen. Segertiden skrevs till 1.16,4a/2.120 meter.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6 Danska toppstoet <strong>Ivana Nordic</strong> (e. Explosive Matter-Thai Tanisha), 1.13,3am/1.221.327 dkk, byter tränare och flyttas från Nicklas Korfitsen till Frode Hamre i Norge. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/ay2x5636ivananordic-617x412.jpg" alt="" class="wp-image-650673"/><figcaption class="wp-element-caption">Ivana Nordic (invändigt) och Nicklas Korfitsen. Foto: Kjeld Mikkelsen/KM FOTO</figcaption></figure>



<p>Femåriga Ivana Nordic har en stark meritlista att se tillbaka på. Treåringssäsongen innehöll segrar i Danskt Stokriterium och Jydskt 3-åringspris, medan hon vann Ålborgs Stochampionat och slutade tvåa i Danskt Stoderby ifjol bakom <strong>Juno</strong>.</p>



<p>– En av anledningarna till att jag tar henne till Norge är att det kommer att finnas fler lopp för ston under den här säsongen, säger Öjvind Skoie (Skoie Racing) till <a href="https://travservice.dk/ivana-nordic-sendt-i-traening-i-norge/" data-type="link" data-id="https://travservice.dk/ivana-nordic-sendt-i-traening-i-norge/" target="_blank" rel="noreferrer noopener">travservice.dk</a>.</p>



<p>I oktober förra året bjöds Ivana Nordic ut på travauktioner.dk, men klickades tillbaka för 295.000 danska kronor.</p>



<p>Ivana Nordic är fallen efter <strong>Explosive Matter</strong> och norskan <strong>Thai Tanisha </strong>(e. Credit Winner), 1.15,8a/101.500 nok. Modern har också lämnat <strong>Thai Mississipp</strong>i (e. Broadway Hall), 1.14,4am/588.780 nok, och <strong>Thai Sarahya</strong> (e. Broadway Hall), 1.14,9a/418.000 nok.</p>



<p>Mormor är norska Kriterie-tvåan <strong>Sweetpike</strong> (e. Ideal du Gazeau-Costa Plenty), 1.13,6ak*/532.423 nok, och hon är utsedd till ”Elitsto” i Norge. Där har hon lämnat Elitloppstvåan <strong>Thai Tanic</strong> (e. Viking Kronos), 1.09,9a/8.456.701 nok, och <strong>Thai Tanium</strong> (e. Running Sea), 1.11,5a/1.434.102 nok.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7 Med världens vinstrikaste sto genom tiderna – <strong>Moni Maker</strong> – som mormors mor och <strong>Bold Eagle</strong> som far drog sexåriga och blivande fölstoet <strong>Future Sox</strong>, 1.10,9ak/1.061.8212 kr, iväg prismässigt. Agenten Thomas Svensen hade det högsta budet och ”klubban” slogs på 560.000 kronor. Sex vinster på 40 starter har det blivit för Future Sox i regi Jörgen S Eriksson.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/05/monimakerheat-617x421.jpg" alt="" class="wp-image-87161"/><figcaption class="wp-element-caption">Moni Maker. Foto Stefan Melander/Stalltz.se
</figcaption></figure>



<p>Future Sox är undan ostartade <strong>Moni Sox</strong> (e. Explosive Matter), vars mor <strong>Live Moni </strong>(e. Conway Hall-Moni Maker) inte heller hittade till tävlingsbanan och som har sin främsta avkomma i <strong>Moni For Lindy</strong> (e. Credit Winner), 1.10,7*/$429.248.</p>



<p>Stall Denco köpte tre hästar; den fyraårige valacken<strong> Love Happens</strong> (e. Make It Happen-Emmylou Love), 1.15,5am/68.500 kr, kostade 290.000 kronor, femårige <strong>Västerbo M.A.S.H.</strong> (e. Readly Express-Västerbo Mixedlove), 1.13,0ak/285.199 kr, gick loss för 210.000 kronor och för sexårige<strong> Loaded Rashid</strong> (e. Propulsion-Belize Boko), 1.12,3ak/271.500 kr, var prislappen 70.000 kronor.</p>



<p><a href="https://www.travera.nu/auktionsresultat/" data-type="link" data-id="https://www.travera.nu/auktionsresultat/" target="_blank" rel="noreferrer noopener">Samtliga resultat Travera-auktionen hittar ni här.</a></p>
