<div class="factbox right minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Paris-Turfs ranking								</h3>
<div class="content">
<ul class="wp-block-list">
<li>3 Jushua Tree</li>
<li>2 Go On Boy</li>
<li>7 Inmarosa</li>
<li>5 Hokkaido Jiel</li>
<li>16 Iroise de la Noe</li>
<li>14 Jabalpur</li>
<li>4 Iguski Sautonne</li>
<li>9 Josh Power</li>
<li>8 Just Love You</li>
<li>15 Jango Vici</li>
<li><strong>11 Icebreaker</strong></li>
<li><strong>10 Crown</strong></li>
<li><strong>1 Borups Victory</strong></li>
<li>12 Jazzman Debailleul</li>
<li>13 J’aime Le Foot</li>
<li>6 Hooker Berry</li>
</ul></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p class="has-drop-cap">1 Idag sker första mötet mellan de franska topptravarna <strong>Jushua Tree</strong> (e. Bold Eagle) och <strong>Go On Boy </strong>(e. Password) i Prix de Bourgogne (€120.000) över 2.100 meter autostart.</p>



<p>– Jushua Tree har bättre form än Go On Boy. Om det blir något mer lopp (läs Prix de Belgique, reds. anm.) innan Prix d’Amérique bestämmer jag efter starten idag, säger tränaren Roman Derieux till Paris-Turf.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/img3760-617x411.jpg" alt="" class="wp-image-787827"/><figcaption class="wp-element-caption">Jushua Tree och Jean-Michel Bazire. Foto: Scoopdyga</figcaption></figure>



<p>Tre svensktränade travare dyker upp i Prix de Bourgogne. Förutom redan Prix d’Amérique-inkvalade <strong>Borups Victory </strong>(e. Googoo Gaagaa) är också Daniel Redén på jakt efter en finalbiljett med <strong>Crown </strong>(e. Chapter Seven) och samma visa gäller för Mattias Djuses <strong>Icebreaker </strong>(e. Chocolatier). De fyra första i mål är klara för Prix d’Amérique 2026.</p>



<p><strong>Prix de Bourgogne </strong>(€120.000)<br>4-10 år.<br><strong>Priser: </strong>54.000-30.000-16.800-9.600-6.000-2.400-1.200 euro.<br><em>2.100 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Borups Victory</strong> (e. Googoo Gaagaa) – Daniel Wäjersten</li>



<li><strong>Go On Boy </strong>(e. Password) – Romain Derieux</li>



<li><strong>Jushua Tree</strong> (e. Bold Eagle) – Jean-Michel Bazire/Nicolas Bazire</li>



<li><strong>Iguski Sautonne</strong> (e. Village Mystic) – Matthieu Abrivard</li>



<li><strong>Hokkaido Jiel </strong>(e. Brillantissime) – David Thomain/Jean-Luc Dersoir</li>



<li><strong>Hooker Berry </strong>(e. Booster Winner) – Damien/BonneAntoine Lherete</li>



<li><strong>Inmarosa </strong>(e. Amiral Sacha) – Francois Lagadeuc/Laurent-Claude Abrivard</li>



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



<li><strong>Josh Power</strong> (e. Offshore Dream) – Sébastian Ernault</li>



<li><strong>Crown (</strong>e. Chapter Seven) – Paul-Philippe Ploquin/Daniel Redén</li>



<li><strong>Icebreaker </strong>(e. Chocolatier) – Eric Raffin/Mattias Djuse</li>



<li><strong>Jazzman Debailleul </strong>(e. Repeat Love) – Franck Nivard/Erno Szirmay</li>



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



<li><strong>Jabalpur</strong> (e. Booster Winner) – Gabriele Gelormini/Alain Chavatte</li>



<li><strong>Jango Vici </strong>(e. Dragon des Racques) – Benjamin Rochard/Antonio Ripoll Rigo</li>



<li><strong>Iroise de la Noe</strong> (e. Tornado Bello) – Thomas Levesque</li>
</ol>


<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Prix d&#8217;Amérique 2026								</h3>
<div class="content">
<p><strong>Regler för Prix d’Amérique 2026</strong></p>
<p><strong>Prix d’Amérique </strong>(€1.000.000) <br />4-11 år, hingstar och ston. <br /><strong>Priser:</strong> 450.000-250.000-140.000-80.000-50.000-20.000-10.000 euro. 2.700 meter.</p>
<p>Vinnaren av Criterium Continental och Prix Tenor de Baune plus de fyra första hästarna i Prix de Bretagne, Prix du Bourbonnais, Prix de Bourgogne och Prix de Belgique är garanterade plats i Prix d’Amérique. Resterande hästar tas ut efter pengar.</p>
<ul class="wp-block-list">
<li>Fyraåringar får skriva upp sina prispengar med 30 procent</li>
<li>Femåringar får skriva upp sina prispengar med 20 procent</li>
<li>Sexåringar får skriva upp sina prispengar med 10 procent</li>
<li>För de äldre hästarna (sju-elva år) gäller deras faktiska prissumma.</li>
</ul>
<p>För deltagande krävs att hästarna tjänat minst 13.000 euro sedan 1 januari 2025 och att deltagit i lopp sedan 1 oktober ifjol, plus att fyra-sexåringar tjänat minst 150.000 euro under karriären och för sju-elvaåringar gäller att de tjänat 200.000 euro under samma tidsperiod.</p>
<p>För att få deltaga i Prix d’Amérique som kusk ska vederbörande vunnit 35 lopp, varav tio måste skett i sulky och personen ifråga ska ha professionell licens.</p>
<p>Prix d’Amérique hålls söndagen den 25 januari. Första strykningen är onsdagen den 21 januari klockan 10.00 den definitiva startlistan spikas 22 januari klockan 12.00.</p>
<h2 class="wp-block-heading">Datumen för att kvala in till Prix d’Amérique:</h2>
<p><strong>Datum – Lopp (prissumma) – Distans</strong></p>
<ul class="wp-block-list">
<li>16 november – <strong>Prix de Bretagne </strong>(€120.000) – 2.700 meter<br /><em>– Josh Power, Jushua Tree, Borups Victory, J’aime Le Foot</em></li>
<li>7 december – <strong>Prix du Bourbonnais</strong> (€120.000) – 2.850 meter<br /><em>– Inmarosa, Keep Going, Izoard Vedaquais, Harmony du Rabutin</em></li>
<li>21 december – <strong>Criterium Continental</strong> (€240.000) – 2.100 meter, auto<br /><em>– Liza Jozzelyn</em></li>
<li>21 december – <strong>Prix Tenor de Baune</strong> (€240.000) – 2.700 meter.<br /><em>– Epic Kronos</em></li>
<li>28 december – <strong>Prix du Bourgogne</strong> (€120.000) – 2.100 meter, auto<br /><em>– Jushua Tree, Go On Boy, Inmarosa, Hokkaido Jiel</em></li>
<li>11 januari – <strong>Prix de Belgique</strong> (€120.000) – 2.850 meter.</li>
</ul></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p>Mer blågult blir det i Prix de Tournon (€56.000) och där startar Timo Nurmos <strong>Barn Ready </strong>(e. Ready Cash) med Björn Goop i sulkyn. I samma lopp tar Christoffer Eriksson ut <strong>Jubii Vang</strong> (e. Maharajah) och David Persson <strong>Let Me In</strong> (e. Bold Eagle). Startar gör också svenskfödda duon <strong>Trogir</strong> (e. Love You) och <strong>Underground Artist</strong> (e. Royalty For Life). </p>



<p>I sadelloppet Prix de Bouvron (€59.000) plockar Olle Alsén ut <strong>Joy Alissa</strong> (e. Maharajah) och där startar också svenskfödde <strong>Huis Clos</strong> (e. Bird Parker). </p>



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



<p class="has-drop-cap">2 Efter 209 starter tar en lång karriär slut idag på <strong>Bergsåker</strong> (första start 12.20) när hemmamatören Clas-Göran Strids 15-årige kallblod <strong>Lapp Love</strong> (e. Love) gör sin sista start innan han faller för åldersstrecket vid årsskiftet.</p>



<p>När Lapp Love slutade oplacerad på Bergsåker före jul i start 208 slog han ”svenskt rekord” när han passerade stoet <strong>Orringstösens</strong> (född 1962) svit av segerlösa lopp från debuten. Hon gjorde nämligen 207 starter utan att vinna lopp. Lapp Love har hunnit med 208 starter (0-13-27) och sprungit in 668.450 kronor.</p>



<p>Flest starter utan seger i Sverige har <strong>Vinnsnopp </strong>(född 1979), som gjorde 299 starter på raken utan att sätta nosen först. Vinnsnopp hade dock vunnit lopp innan den sviten tog vid.</p>



<p>Årsfinalen på Bergsåker har breddplus-status. Årets champion Mats E Djuse och alla andra kuskar som körde över 150 lopp förra året är därmed utestängda.</p>



<p>Bland de fyrbenta återkommer <strong>Re Alkapital</strong> (e. Pydin) efter några månaders tävlingsuppehåll. Hästen var finalist i både svenska och norska Derbyt förra året och hade en fin period i somras för sin nye tränare Jan Ove Olsen. Bland annat var han knappt slagen – hals – av norske <strong>Ness Tjo Tyr</strong> i ett försök till kallblodsdivisionen i somras.<br><a href="https://sulkysport.se/wp-content/uploads/2025/12/28v4.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/12/28v4.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bergsåkers tävlingar.</a></p>



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



<p class="has-drop-cap">3 V85-spelet går på export i tre dagar med start idag inför avslutningen på Axevalla på nyårsafton. Norska <strong>Momarken</strong> (första start 15.20) tar hand om dagens omgång och en del svenskar reser över gränsen.</p>



<p>Ett dussin svensktränade hästar finns med på V85-kupongen, där Kristian Lindberg ser ut att sitta bakom bästa chansen i fyraåriga stoet <strong>Hickovelocissimo</strong> (e. Explosive Matter).</p>



<p>Lillasystern till topphästen <strong>Policy of Truth</strong> (e. Explosive Matter), 1.09,6ak/5.911.400 kr, har själv vunnit fyra lopp i år och kommer från vinst i en avdelning i Guldklockan på Solvalla veckan före jul. Då vann hon från ledningen på finfint sätt.</p>



<p>Dagens mest meriterade häst på Momarken är sexfaldige miljonären <strong>Stumne Fyr </strong>(e. Joker Elden), som ställs mot <strong>Baias </strong>(e. Smedheim Solan) i högsta kallblodsklassen. Duon startar från tillägg över sprinterdistans.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/12/28v85.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/12/28v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Momarkens tävlingar idag.</a></p>



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



<p class="has-drop-cap">4 Vintermeetinget på Vincennes har pågått i snart två månader och<strong> Face Time Bourbon</strong> (e. Ready Cash) har klivit upp som etta bland avelshingstarna. Hans avkommor har inte bara tjänat mest pengar – 983.680 euro – utan också vunnit flest lopp – 13 segrar – per den 25 december. Hans far <strong>Ready Cash</strong> (e. Indy de Vive) har dominerat under många år, men är ”bara” tvåa med 781.180 euro.</p>



<p>Noteras kan också att övervägande del av Face Time Bourbons vinstsumma har kommit i sulkylopp, eller 949.900 av 983.680 euro. Inkomsten i monté är blott 33.780 euro. Vinstrikaste sadelhingst är <strong>Royal Dream</strong> (e. Love You) med 215.430 euro och han följs av <strong>Express Jet</strong> (e. Goetmals Wood) med 203.250 euro.</p>



<h2 class="wp-block-heading">Fem vinstrikaste avelshingstarna</h2>



<p><strong>Namn (far) – Starter – Segrar – Prispengar (Euro)</strong></p>



<ol class="wp-block-list">
<li><strong>Face Time Bourbon</strong> (e. Ready Cash) – 132 – 13 – €983.680</li>



<li><strong>Ready Cash</strong> (e. Indy de Vive) – 154 – 11 – €781.180</li>



<li><strong>Village Mystic</strong> (e. Love You) – 68 – 10 – €507.550</li>



<li><strong>Royal Dream</strong> (e. Love You) – 73 – 9 – €461.130</li>



<li><strong>Love You</strong> (e. Coktail Jet) – 90 – 12 – €414.520</li>
</ol>



<p><strong>Fotnot: </strong>vinstrikaste avelshingstar på Vincennes under vintermeetinget 30 oktober-25 december.</p>



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



<p class="has-drop-cap">5 Intresset för att kvala tvååringar är stort i Frankrike och per den 25 december har 2.748 hästar födda 2023 kvalat. Det betyder att 30,76 procent av kullen som bestod av 8.934 hästar har genomgått kval sedan maj månad. 49 av 2023-kullens hästar har noterat 1.17 eller bättre.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/skarmavbild20250603kl.11.27.39-617x386.jpg" alt="" class="wp-image-726686"/><figcaption class="wp-element-caption">Nelson du Bas Bosq och Yoann Lebourgeois vid sin överlägsna kvalvinst.</figcaption></figure>



<p>Snabbast är <strong>Nelson du Bas Bosq </strong>(e. Good Boy Ligneries-Carte Majyc) och redan i början av juni kvalade han på 1.14,1 över 2.000 meter. Tvååringen köptes av Roland Wiksten i höstas.</p>



<p>Så här många tvååringar har kvalat månad för månad i Frankrike: <strong>maj</strong> (341), <strong>juni</strong> (460), <strong>juli </strong>(395), <strong>augusti </strong>(267), <strong>september</strong> (332), <strong>oktober </strong>(451), <strong>november</strong> (256) och <strong>december</strong> (246).</p>



<p>Noteras kan också att ifjol kvalade 2.840 av den franska kullens 9.178 tvååringar ifjol, eller 30,94 procent. </p>



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



<p class="has-drop-cap">6 Meadowlands höjer återigen prispengarna. Ifjol ökade prissumman från 17,2 till 17,6 miljoner dollar. Nästa år blir det ytterligare en miljon dollar mer att tävla om och det betyder 18,6 miljoner dollar. För travhästarnas del höjs prispengarna i Delvin Miller Memorial för treåriga ston från 283.000 till 338.000 dollar, medan den lägre klassen i New Jersey Stakes – ”Silver Series” – för två- och treåringar går från 670.000 till 750.000 dollar.</p>



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



<p class="has-drop-cap">7 Två Grupp III-lopp för tvååringar – Criterium Sud (€30.030) – hölls i fredags i Taranto. Snabbast var <strong>Ihaveadream Gar</strong> (e. Greenshoe-Seibella Park) i hingstarnas uppgörelse. För Giuseppe d’Alconzo travade han 1.13,6a/1.600 meter efter omgående tagit hand om ledningen. Sista 100 meterna blev det stumma ben och han höll undan med huvud för Ideal Top (e. Tesoro Degli Dei).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/12/skarmavbild20251227kl.09.15.51-617x377.jpg" alt="" class="wp-image-806496"/><figcaption class="wp-element-caption">Invändige Ihaveadream Gar håller undan för Ideal Top.</figcaption></figure>



<p>Därmed är Ihaveadream Gar fortsatt obesegrad efter fem starter. Modern och Oaks del Trotto-fyran <strong>Seibella Park</strong> (e. Varenne), 1.11,9/€208.074, har förutom Ihaveadream Gar, 1.12,9*/€24.516, lämnat <strong>Ermes Gar</strong> (e. What the Hill), 1,13,6/€22.879.</p>



<p>Stonas uppgörelse gick till <strong>Incontrada Grif </strong>(e. Green Manalishi-One Dream Grif) och Antonio Simioli på 1.15,9a/1.600 meter. Duon smög med i andra utvändigt på sista bortre långsidan innan luckan uppenbarade sig mitt på upploppet och det räckte för att hinna fram till tredje segern i karriären på sex starter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/12/skarmavbild20251227kl.09.11.43-617x401.jpg" alt="" class="wp-image-806495"/><figcaption class="wp-element-caption">Incontrada Grif spurtar till vinst.</figcaption></figure>



<p>Incontrada Grif, 1.15,4/€20.624, är undan <strong>One Dream Grif </strong>(e. Varenne), 1.13,0/€48.592, vilken också är mor till <strong>Zoe Grif Italia </strong>(e. Ready Cash), 1.10,8/€71.632, och <strong>Borg Grif</strong> (e. Conway Hall), 1.12,1*/€61.523.</p>
