
<p class="has-drop-cap wp-block-paragraph">1 Fyra platser står på spel till Prix d’Amérique (€1.000.000) i Prix de Bretagne (€120.000) idag på Vincennes och från svenskt håll ska Daniel Wäjersten och Daniel Redén försöka kvala in <strong>Borups Victory</strong> (e. Googoo Gaagaa) respektive <strong>Epic Kronos</strong> (e. Muscle Hill).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/borupsvictory1-617x333.jpg" alt="" class="wp-image-604186"/><figcaption class="wp-element-caption">Borups Victory och Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Prix de Bretagne</strong> (€120.000)<br>4-10 år.<br><em>2.700 meter.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Epic Kronos</strong> (e. Muscle Hill) – Paul-Philippe Ploquin/Daniel Redén</li>



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



<li><strong>Keep Going</strong> (e. Follow You) – Mathieu Mottier</li>



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



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



<li><strong>Krack Time Atout </strong>(e. Face Time Bourbon) – Frank Nivard/Sébastien Guarato</li>



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



<li><strong>Kana de Beylev </strong>(e. Express Jet) – Eric Raffin/William Bigeon</li>



<li><strong>Jean Balthazar </strong>(e. Alto de Viette) – Pascal Castel</li>



<li><strong>Ina du Rib</strong> (e. Uhlan du Val) – Jean-Loïc Claude Dersoir/Joël Hallais</li>



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



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



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



<li><strong>Izoard Vedaquais</strong> (e. Bird Parker) – Benjamin Rochard/Philippe Allaire</li>



<li><strong>Hirondelle du Rib</strong> (e. Rolling d’Heripre) – Noé Perron/Joël Hallais</li>



<li><strong>Borups Victory </strong>(e. Googoo Gaagaa) – Daniel Wäjersten</li>



<li><strong>Just A Gigolo</strong> (e. Boccador de Simm) – Yoann Lebourgeois/Philippe Allaire</li>



<li><strong>Ideale du Chene</strong> (e. Bird Parker) – Jean-Robert Declercq/Julien le Mer</li>
</ol>


<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 rank								</h3>
<div class="content">
<p class="wp-block-paragraph">13 Jushua Tree<br />14 Izoard Vedaquais<br />7 Josh Power<br />4 Justin Bold<br />11 Just Love You<br />5 Iguski Sautonne<br />3 Keep Going<br />1 Epic Kronos<br />12 Hokkaido Jiel<br />6 Krack Time Atout<br />16 Bourps Victory<br />8 Kana de Beylev<br />17 Just A Gigolo<br />2 J’aime Le Foot<br />18 Ideale du Chene<br />10 Ina du Rib<br />15 Hirondelle du Rib<br />9 Jean Balthazar</p>
</p></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="wp-block-paragraph">Favorit till segern – och rankad etta i Paris-Turf – är <strong>Jushua Tree</strong> (e. Bold Eagle) och Jean-Michel Bazire efter uppvisningen i Prix de Cevennes (€90.000) i senaste framträdandet. Av de blågula hästarna håller Paris-Turf Epic Kronos högst och han raknas som åtta och Borups Victory som nummer elva.</p>



<p class="wp-block-paragraph">– Det här loppet passar bra in i hans program och han håller sin form, säger Jean-Michel Bazire 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>


<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 class="wp-block-paragraph"><strong>Regler för Prix d’Amérique 2026</strong></p>
<p class="wp-block-paragraph"><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 class="wp-block-paragraph">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 class="wp-block-paragraph">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 class="wp-block-paragraph">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 class="wp-block-paragraph">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 class="wp-block-paragraph"><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.<br /><em>– Iroise de la Noe, Frank Gio, Immortal Doc, King Opera</em></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-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 Förutom Prix de Bretagne bjuder <strong>Vincennes </strong>(första start kl. 13.23) på flera andra topplopp och ett koppel blågula travare. I sadelloppet Prix des Hippodromes du Morhiban (€46.000) över 2.175 meter startar tre svenskfödda travare; Antti Ojanperäs <strong>Goodwin Zet </strong>(e. Hard Livin), Björn Goops <strong>Månskenstösen </strong>(e. Bird Parker) och Markus B Svedbergs <strong>Battuta Face</strong> (e. Mosaique Face).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/00255317014scoopdyga-617x411.jpg" alt="" class="wp-image-623668"/><figcaption class="wp-element-caption">Ninepoints Lasse.  Foto: Scoopdyga</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Westholm plockar ut <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) i Prix de Cosse le Vivien (€68.000) och i samma lopp startar Antti Ojanperä <strong>Combat Fighter</strong> (e. From Above).</p>



<p class="wp-block-paragraph">Fem blågula travare dyker upp i Prix d’Aigus Mortes (€56.000); Daniel Redéns <strong>Chestnut </strong>(e. Jocose), Thierry Duvaldestins <strong>Mister Invictus </strong>(e. Ready Cash), Per-Emil Henrikssons <strong>Darlington Fame</strong> (e. Canepa Hanover), Joakim Eskilssons <strong>Master of Zon </strong>(e. The Bank) och Erik Bondos <strong>Sidney Celeber </strong>(e. Readly Express).</p>



<p class="wp-block-paragraph">Mer svenskt är det i Prix de Boissy-Saint-Leger (€80.000) och där startar Simon Rousselle <strong>Pantocrator </strong>(e. Quarcio du Chene).</p>



<p class="wp-block-paragraph">Dessutom avgörs två semi-classique-löpningar för treåringar och där Prix Pierre Plazen (€120.000) drar till sig störst intresse. Där möts <strong>Mack de Blary </strong>(e. Face Time Bourbon) och <strong>Ginostrabliggi</strong> (e. Muscle Hill) över 2.700 meter.</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2025-11-16/7500" data-type="link" data-id="https://www.letrot.com/courses/programme/2025-11-16/7500" target="_blank" rel="noreferrer noopener">Startlistorna till Vincennes tävlingar hittar ni här.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/2danielreden-617x333.jpg" alt="" class="wp-image-722952"/><figcaption class="wp-element-caption">Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3För första gången i historien har en svensk travtränare passerat 50 miljoner kronor till  stallet. Efter lördagens succé med bland annat två finalsegrar i Breeders Crown har Daniel Redéns hästar sprungit in 50,038.081 kronor under 2025!</p>



<p class="wp-block-paragraph">Det tidigare rekordet hade Åke Svanstedt från 2012 när hans hästar sprang in 48.091.124 kronor.<br>– Rekord är till för att slås. Det är kul. Vi har haft en fantastisk dag och hästarna har presterat. Jag är tränare och man vill vara där uppe när man kommit dit, så det betyder mycket. Det är klart att man går och tänker på rekord. Ett bra år! sade Daniel Redén till ATG Live.</p>



<p class="wp-block-paragraph"><strong>Sverige vinstrikaste tränarchampions:</strong></p>



<ul class="wp-block-list">
<li>2025* – Daniel Redén – Solvalla – 50.038.061</li>



<li>2012 – Åke Svanstedt – Axevalla – 48.091.124</li>



<li>2024 – Daniel Redén – Solvalla – 46.534.337</li>



<li>2022 – Daniel Redén – Solvalla – 45.675.799</li>



<li>2011 – Åke Svanstedt – Axevalla – 45.476.622</li>



<li>2018 – Daniel Redén – Solvalla – 43.393.660</li>
</ul>



<p class="wp-block-paragraph"><em>*per den 15 november.</em></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/martinssonbernth2-e1761897432836-617x383.jpg" alt="" class="wp-image-787112"/><figcaption class="wp-element-caption">Bernth Martinsson. Foto Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Under 36 år med start på 1960-talet var kuskmatchen Charlie Mills Trot en riktig höjdare på Romme. Mångårige sekreteraren och sportchefen på dalatravet, Bernth Martinsson, höll i tåtarna med hjälp av Elitloppsgeneralen Rune Stolt när stjärnkuskar från hela världen gjorde resan till Dalarna.<br>”<em>Att få se Frömming, Krüger, O’Brien, Gougeon, Miller, Haughton, Baldis, Wewering, Thoresen, Kontio, bröderna Nordin, Stig H, Goop, Lindstedt, körsvenner från exotiska Australien och Nya Zeeland med flera på lilla Romme var en sensation som varje år lockade en jättepublik</em>,” har Martinsson tidigare skrivit själv.</p>



<p class="wp-block-paragraph">I eftermiddag på <strong>Romme</strong> (första start 14.05)  hyllas banans mångårige medarbetare med en final för vardera final och 100.000 kronor till vinnaren i varje. För att få vara med i finalerna krävs minst tre starter i Rättvik eller på Romme under säsongen.</p>



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



<p class="wp-block-paragraph"><em>Vill du läsa mer om Bernth Martinsson? Missa inte förra veckans stora intervju med dalatravets stora profil.</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/nar-martinsson-minns/">Läs mer om Bernth Martinsson här!</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5 Dubbla Grupp I-löpningar – finalerna i Anact Stakes Plus+ (€200.2000) – för tvååringar bjuds det på i <strong>Neapel</strong> (första start kl. 15.050) idag. I stonas uppgörelse jagar obesegrade <strong>I Love America</strong> (e. Muscle Hill) sjunde raka triumfen tillsammans med Santo Mollo.</p>



<p class="wp-block-paragraph">Även i hingstarnas uppgörelse dyker en obesegrad travare upp. Andrea Farolfi och <strong>Iceberg Lp</strong> (e. Face Time Bourbon) har vunnit tre lopp och ställs bland annat mot <strong>Iambellesi Tq</strong> (e. El Ideal) och Marco Stefani.</p>



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



<p class="wp-block-paragraph"><strong>Anact Stakes Plus+ </strong>(€200.2000)<br>Tvååriga ston.<br><em>1.600 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Irene Mail </strong>(e. Nad al Sheba) – Lorenzo Baldi</li>



<li><strong>In Scream Gio</strong> (e. Gimpanzee) – Vincenzo Luongo</li>



<li><strong>I Love America </strong>(e. Muscle Hill) – Santo Mollo</li>



<li><strong>Imagination Club</strong> (e. In Range) – Andrea Farolfi</li>



<li><strong>Incontrada Grif</strong> (e. Green Manalishi) – Antonio Simioli</li>



<li><strong>Ingrid Am</strong> (e. El Ideal) – Alessandro Gocciadoro</li>



<li><strong>Idra Pal Bar</strong> (e. Face Time Bourbon) – Marco Smorgon</li>



<li><strong>Isabelle Effe </strong>(e. Googoo Gaagaa) – Vincenzo Gallo</li>



<li><strong>Ice Killer Gar</strong> (e. Googoo Gaagaa) – Pietro Gubellini</li>



<li><strong>Imapala Wise As</strong> (e. Maharajah) – Antonio di Nardo</li>



<li><em>Iride Degli Dei (e. El Ideal) – struken</em></li>



<li><strong>Ifinoe Degli Dei</strong> (e. The Bank) – Enrico Bellei</li>
</ol>



<p class="wp-block-paragraph"><strong>Anact Stakes Plus+ </strong>(€200.2000)<br>Tvååriga hingstar.<br><em>1.600 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Itan Pal Ferm</strong> (e. The Bank) – Antonio Simioli</li>



<li><strong>Iceberg Lp</strong> (e. Face Time Bourbon) – Andrea Farolfi</li>



<li><strong>Izoard Blue Grif</strong> (e. Readly Express) – Andrea Guzzinati</li>



<li><strong>Instagram Bi </strong>(e. Tactical Landing) – Vincenzo Luongo</li>



<li><strong>Iambellesi Tq</strong> (e. El Ideal) – Marco Stefani</li>



<li><strong>Iago Roc</strong> (e. Nad al Sheba) – Filippo Rocca</li>



<li><strong>Ice Gio</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Invictus Bi </strong>(e. Axl Rose) – Enrico Bellei</li>



<li><strong>Invictus Kb Font </strong>(e. Ringostarr Treb) – Pietro Gubellini</li>



<li><strong>Il Trio Jet </strong>(e. Wishing Stone) – Santo Mollo</li>



<li><strong>Ippotamo Tq</strong> (e. Nuncio) – Antonio di Nardo</li>



<li><strong>Ideal Turdance</strong> (e. El Ideal) – Marco Smorgon</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/taarnelunden-617x823.jpg" alt="" class="wp-image-793304"/><figcaption class="wp-element-caption">Charlottenlund.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6 Charlottenlund är ordentligt på hugget sedan det danska centralförbundet delat ut ett Alexanderhugg till Det Danske Travselskab.</p>



<p class="wp-block-paragraph">I samband med onsdagens bolagsstämma – skriver Charlottenlund i ett pressmeddelande – fanns ett starkt stöd och enighet om att fortsätta den positiva utveckling som har inletts kring Det Danske Travselvskab.</p>



<p class="wp-block-paragraph">Detta innebär ett antal nya och spännande initiativ och däribland Super Sundays. Under andra halvan av 2026 kommer Super Sundays att introduceras på Lunden, vilket innebär en fördubbling av prispengarna, samt en ny serie med namnet ”Lunden Point”, som främst riktar sig till amatörer, med särskilt fokus på tvååriga hästar. Från 2027 kommer Super Sundays att bli permanent under hela året med en tredubbling av prispengarna.</p>



<p class="wp-block-paragraph">Ett nytt talangutvecklingsprogram kallat Masterclass att införas 2026, som erbjuder utvalda unga travtalanger en betald utvecklingskurs som syftar till att inspirera, motivera och utbilda de deltagande för en framtida karriär inom travsporten.</p>



<p class="wp-block-paragraph">Ett program för att stödja avel, som ännu inte har utformats, är också på gång – utvecklingen inom detta område måste vändas.</p>



<p class="wp-block-paragraph">Charlottenlund kan också berätta att travsällskapets ekonomi stärks genom försäljningen av en parkeringsplats som inte längre behövs. Allt detta kommer att säkerställa långsiktig ekonomisk stabilitet för Travselskab, som därmed kommer att vara en aktiv drivkraft i utvecklingen av dansk travsport under de kommande åren, skriver Charlottenlund i sin pressrelease.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Hur alla turerna runt Charlottenlund och dansk travsport kommer att sluta återstår att se…i fredags höll danska travförbundets ordförande Stig Holt Hartwig och vd Pål M. Tung ett videomöt med frågor på spelbolaget Bet25:s hemsida. Där berättar duon om dansk travsports dystra läge och framtid.</p>



<figure class="wp-block-embed is-type-video is-provider-youtube wp-block-embed-youtube wp-embed-aspect-16-9 wp-has-aspect-ratio"><div class="wp-block-embed__wrapper">
<iframe title="Orienteringsmøde for Dansk Hestevæddeløbssport" width="500" height="281" src="https://www.youtube.com/embed/wErGyNlxHIA?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
</div></figure>



<p class="has-text-align-center wp-block-paragraph"></p>
