
<p class="has-drop-cap wp-block-paragraph">1 Tre Grupp I-löpningar och ett Grupp II-lopp bjuds på i Treviso idag. Örjan Kihlström kör i samtliga lopp och sitter upp bakom den Alessandro Gocciadori-tränade kvartetten <strong>Lemmy </strong>(e. Just A Gigolo), <strong>Lisippa Degli Dei</strong> (e. International Moni), <strong>Dany Capar </strong>(e. Exploit Caf) och <strong>Geber’s Dream </strong>(e. Donato Hanover).</p>



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



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



<ol class="wp-block-list">
<li><strong>Lemmy</strong> (e. Just A Gigolo) – Örjan Kihlström</li>



<li><strong>Lince Killer Gar</strong> (e. Ringostarr Treb) – Antonio di Nardo</li>



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



<li><strong>Lucenzo Ral</strong> (e. Victor Gio) – Marco Stefani</li>



<li><strong>Lets Go Gio</strong> (e. Tony Gio) – Luigi Cuozzo</li>



<li><strong>Loki Pal Bar</strong> (e. Father Patrick) – Roberto Vecchione</li>



<li><strong>Leopold Ferm</strong> (e. Nad al Sheba) – Giampaolo Minnucci</li>



<li><strong>Leroy Sp</strong> (e. Bengurion Jet) – Andrea Farolfi</li>



<li><strong>Luxor Roc</strong> (e. Ringostarr Treb) – Filippo Rocca</li>



<li><strong>Leao</strong> (e. Trixton) – Vincenzo P Dell’Annunziata</li>



<li><strong>Lupin Doda</strong> (e. Maharajah) – Andrea Guzzinati</li>



<li><strong>Lolo</strong> (e. Greenshoe) – Enrico Bellei</li>
</ol>



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



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



<ol class="wp-block-list">
<li><strong>Leonia Dance</strong> (e. El Ideal) – Simone Mollo</li>



<li><strong>Lady Hawk Font</strong> (e. Idao de Tillard) – Edoardo Loccisano</li>



<li><strong>Lovely Grif</strong> (e. Nad al Sheba) – Andrea Farolfi</li>



<li><strong>Leslie Dance</strong> (e. El Ideal) – Marco Smorgon</li>



<li><strong>Lisippa Degli Dei</strong> (e. International Moni) – Örjan Kihlström</li>



<li><strong>Lotteria</strong> (e. Greenshoe) – Santo Mollo</li>



<li><strong>Lilibeth Baba</strong> (e. Father Patrick) – Francesco Facci</li>



<li><strong>Lisa Gso</strong> (e. Don Fanucci Zet) – Roberto Vecchione</li>



<li><strong>Lolly Grif</strong> (e. Nad al Sheba) – Antonio Di Nardo</li>



<li><strong>Lydia del Ronco</strong> (e. Alrajah One) – Enrico Bellei</li>



<li><strong>Lucy Vimar</strong> (e. Maharajah) – Filippo Gallo</li>



<li><strong>Luxury Gio</strong> (e. Ideal du Pommeau) – Alessandro Gocciadoro</li>
</ol>



<p class="wp-block-paragraph"><strong>Gaetano Turilli</strong> (€165.000)<br>Äldre hästar.<br><em>2.060 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>First of Mind</strong> (e. Face Time Bourbon) – Antonio di Nardo</li>



<li><strong>Follia d’Esi</strong> (e. Ringostarr Treb) – Marco Stefani</li>



<li><strong>Diamond Francis</strong> (e. Exploit Caf) – Andrea Farolfi</li>



<li><strong>Banderas Bi</strong> (e. Ganymede) – Roberto Vecchione</li>



<li><strong>Fil Ek</strong> (e. Ringostarr Treb) – Pietro Gubellini</li>



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



<li><strong>Febo Spritz</strong> (e. Maharajah) – Manuel Pistone</li>



<li><strong>Dimitri Ferm</strong> (e. Nad al Sheba) – Santo Mollo</li>



<li><strong>Dany Capar</strong> (e. Exploit Caf) – Örjan Kihlström</li>



<li><strong>Fierobecco Font</strong> (e. Ringostarr Treb) – Filippo Gallo</li>
</ol>



<p class="wp-block-paragraph"><strong>Gran Premio Domenico Toniatti</strong> (€88.000)<br>Fyraåringar.<br><em>1.609 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Giotto Ek</strong> (e. Vivid Wise As) – Roberto Vecchione</li>



<li><strong>Gloria Italia</strong> (e. Nad al Sheba) – Andrea Farolfi</li>



<li><strong>Mille Etoiles</strong> (e. Prodigious) – Massimo Barbini</li>



<li><strong>Ghibbs Francis</strong> (e. Exploit Caf) – Manuel Pistone</li>



<li><strong>Giovaz</strong> (e. Maharajah) – Antonio di Nardo</li>



<li><strong>Genny Lj</strong> (e. Dontyouforgetit) – Vincenzo P Dell’Annunziata</li>



<li><strong>Geber’s Dream</strong> (e. Donato Hanover) – Örjan Kihlström</li>



<li><strong>Gabrioz</strong> (e. Maharajah) – Alessandro Gocciadoro</li>



<li><strong>Gimmy Top</strong> (e. Readly Express) – Vincenzo Gallo</li>



<li><strong>Golimpio d’Or</strong> (e. Dontyouforgetit) – Ferdinando Minopoli</li>



<li><strong>Golden Boy</strong> (e. Maharajah) – Andrea Guzzinati</li>



<li><strong>Gill Dorial</strong> (e. Dontyouforgetit) – Marco Stefani</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/2026/08/26a3516-617x412.jpeg" alt="" class="wp-image-883062"/><figcaption class="wp-element-caption">Jumbled Story och Leif Eriksson vid debutvinsten. Foto Bodentravet</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Hittills i år har 37 tvååringar i svensk träning vunnit lopp på svensk mark. Flest triumfer har Claes Sjöströms Svampen-vinnare <strong>Rocksteady Artist</strong> (e. Captain Corey), som tog femte raka segern från debuten när han vann försök till Svensk Uppfödningslöpning.</p>



<p class="wp-block-paragraph">Segerrikast i Norrland är Skellefteåamatören Lage Berglunds sto <strong>Jumbled Story</strong> (e. Calgary Games), som vunnit fyra lopp på sex starter. Idag kan hästen kliva upp jämsides med Rocksteady Artist när Jumble Story startar i finalen av Norrlands Elitserie på Bergsåker med 150.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph">Jumble Story är i särklass mest meriterad av de sju tvååringarna i finalen, där en motståndare klivit upp i sexsiffrigt. Daniel Wäjerstens <strong>Liza Kronos</strong> (e. Gimpanzee) har samlat ihop 110.000 kronor på två starter (1-1-0).</p>



<p class="wp-block-paragraph"><strong>Segerrikaste svensktränade tvååringar 2026:</strong><br><em>Häst (far) – Tränare – Resultat</em></p>



<ul class="wp-block-list">
<li><strong>Rocksteady Artist</strong> (e. Captain Corey) – Claes Sjöström – 5 st: 5-0-0</li>



<li><strong>Jumbled Story</strong> (e. Calgary Games) – Lage Berglund – 6 st: 4-1-0</li>



<li><strong>Reilly Westwood</strong> (e. S.J.’s Caviar) – Linda Fyhr – 4 st: 4-0-0</li>



<li><strong>Martha Minow</strong> (e. Readly Express) – Paul Hagoort – 3 st: 3-0-0</li>



<li><strong>Cora Pearl</strong> (e. Feliciano) – Björn Goop – 5 st: 2-0-2</li>



<li><strong>Shankley</strong> (e. Global Welcome) – Åke Lindblom – 5 st: 2-0-0</li>



<li><strong>Just In Time</strong> (e. Calgary Games) – Jasmine Ising – 4 st: 2-0-0</li>



<li><strong>Holofira Z.</strong> (e. Tactical Landing) – André Eklundh – 3 st: 2-0-0</li>
</ul>



<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/2026/08/angsrask7-617x333.jpg" alt="" class="wp-image-883708"/><figcaption class="wp-element-caption">Ängsrask och Robert Skoglund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3 <strong>Bergsåker</strong> (första start 13.45) är enda svenska bana som tävlar och då plockar en hemmatränare ut en Derbyvinnare. Robert Skoglunds fyraåring <strong>Ängsrask</strong> (e. Bork Odin) dyker upp i Bergsåkers Stora Fyraåringslopp, som har en lång historia. Bland moderna vinnare finns <strong>Lannem Silje</strong> (e. Åsajerven), <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.), <strong>Grisle Odin G.L.</strong> (e. Moe Odin), <strong>Majblomster</strong> (e. Tekno Odin) och ifjol svenske Derbyvinnaren <strong>Tangen Martin</strong> (e. Bork Odin).</p>



<p class="wp-block-paragraph">Det sistnämnda kan Ängsrask ordna repris på när han kommer ut tillsammans med Ulf Ohlsson i medeldistansloppet med autostart. Så är nämligen förutsättningarna sedan ifjol, men under många år handlade det om lång distans för fyraåringarna. <strong>Dellenits</strong> (e. B.W. Modde) gällande svenska rekord för fyraåringar över lång distans sattes i just Stora Fyraåringspriset för fyra år sedan, 1.25,9/2.660 meter.</p>



<p class="wp-block-paragraph">För Ängsrask blir det årets sista start under en fenomenal säsong som hittills innehållit tolv starter och åtta segrar.</p>



<p class="wp-block-paragraph">– Det har varit ett väldigt bra år. Han hade lite oflyt när han fick dödens i Prinsessan Madeleines Pokal i maj och när starten blev fördröjd i norska Derbyt, så i de två loppen fick han inte full utdelning. Men annars har han haft ett kanonår och man kan ju inte vinna allt, säger Robert Skoglund till Kanal75.</p>



<p class="wp-block-paragraph">Att förhoppningarna är stora även inför femåringssäsongen råder inga tvivel om.</p>



<p class="wp-block-paragraph">– Det har det känts att han kommer räcka bra även som femåring. Sedan vet jag inte hur det kommer att se ut efter vinterträningen, men utvecklas han lika mycket som han gjorde mellan tre- och fyraåringssäsongen kommer det se väldigt ljust ut nästa år.</p>



<p class="wp-block-paragraph">Även de treåriga kallbloden tävlar om 100.000 kronor och 14 hästar på tre volter gör upp om den stora prischecken. Hälften av deltagarna har varit med i Kriteriet eller Kriteriestoet i Sverige eller Norge i sommar och höst.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/11/15gs75.pdf" target="_blank" rel="noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Lana Henry, 21 år, är den främsta kvinnliga kusken i Frankrike i år med 55 segrar på 360 starter och 850.080 euro. Hon placerar sig som nummer 30 i den franska kuskligan. Hon har redan passerat sitt tidigare rekord från ifjol med 36 vinster.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/lanahenryscoop1411266af70e83e25fb309038052-617x347.jpg" alt="" class="wp-image-921801"/><figcaption class="wp-element-caption">Lana Henry. Foto: Scoopdyga</figcaption></figure>



<p class="wp-block-paragraph">Pappa Yannick Henry är tränare och moster är Nathalie Henry, vilken är den mest meriterade kvinnliga montéryttaren och det var hon som red Scarlet Knight till en andraplats i Prix de Cornulier bakom Jag de Bellouet.</p>



<p class="wp-block-paragraph">Lana Henry har vunnit sju sadellopp, men det är sulkyn som gäller.</p>



<p class="wp-block-paragraph">– När jag tillbringade en vinter hos Jean-Michel Bazire gjorde han allt för att jag skulle satsa på monté med tanke på min kroppsstorlek, men ridning var aldrig min grej. När jag återvände till södra Frankrike sommaren 2024 bestämde jag mig för att sluta rida monté, berättar Lana Henry för ”24 au Trot.”</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Till <strong>Chartres </strong>(första start kl. 13.10) åker tre svensktränade travare för att tävla i <a href="https://www.letrot.com/courses/2026-11-15/2801/8" data-type="link" data-id="https://www.letrot.com/courses/2026-11-15/2801/8" target="_blank" rel="noopener">Prix Ville de Bonneval </a>(€21.000) över 3.300 meter. Det handlar om Jörgen Westholms <strong>Mercenary </strong>(e. Ready Cash), Markus B Svedberg-tränade <strong>Caughtredhanded</strong> (e. Express Bourbon) och Oskar J Anderssons <strong>Ellen Ripley</strong> (e. Mister J.P.). Dessutom startar svenskfödda duon <strong>Redbull Pellini </strong>(e. Readly Express) och <strong>That’s It </strong>(e. Make It Happen).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/jorgenwestholmkeps-617x333.jpg" alt="" class="wp-image-864783"/><figcaption class="wp-element-caption">Jörgen Westholm. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Westholms <strong>Muguet d’Erable</strong> (e. Ready Cash) och Gabriele Gelormini får chansen bakom den Courant-ägde fyraåringen i <a href="https://www.letrot.com/courses/2026-11-15/2801/6" data-type="link" data-id="https://www.letrot.com/courses/2026-11-15/2801/6" target="_blank" rel="noopener">Prix Office Tourisme Bonnevalais</a> (€13.500) i ett lopp över 2.800 meter.</p>



<p class="wp-block-paragraph">Jarmo Niskanen väljer att starta <strong>Maharani </strong>(e. Earl Simon) i <a href="https://www.letrot.com/courses/2026-11-15/5401/3" data-type="link" data-id="https://www.letrot.com/courses/2026-11-15/5401/3" target="_blank" rel="noopener">Prix Association des Courses de Strasbourg</a> (€13.000) i <strong>Nancy</strong> (första start kl. 11.30) och där står fyraåringen med 25 meters tillägg.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 När Peggy Boko (e. Robert Bi-Sue Boko) tog hem <a href="https://sulkysport.se/toppspurt-av-unghaststjarna/" data-type="link" data-id="https://sulkysport.se/toppspurt-av-unghaststjarna/" target="_blank" rel="noopener">Speedy Volita Cup </a>(€19.800) i fredags på Victoria Park på 1.10,0a/1.609 meter blev hon det näst snabbaste svenskfödda fyraåriga stoet på europeisk mark.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/missimperatriceeam220921adamstromstalltz-617x388.jpg" alt="" class="wp-image-357779"/><figcaption class="wp-element-caption">Miss Imperatrice flyger fram till seger på 1.09,9 för Erik Adielsson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Endast <strong>Miss Imperatrice</strong> (e. Mister J.P.) har travat fortare. Den 22 september 2022 vann det Timo Nurmos-tränade stoet på 1.09,9a/1.640 meter på Solvalla.</p>



<p class="wp-block-paragraph">Snabbaste vinnartiden i Europa av fyraåriga ston är Tomas Malmqvists fransyska <strong>Jazzy Perrine </strong>(e. Django Riff), vilken noterade 1.09,0 vid seger på Solvallas Elitloppsdag 2023.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Gran Premio di Capitanata Memorial Luigi Maglione (€35.200) avgjordes i Foggia igår och det blev en ren uppvisning av <strong>Ector Francis</strong> (e. Nad al Sheba-Pandaz di Mazval) sedan han gått till täten efter 600 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/skarmavbild20261114kl.17.57.09-617x356.png" alt="" class="wp-image-921877"/><figcaption class="wp-element-caption">Ector Francis var ensam på målfotot. </figcaption></figure>



<p class="wp-block-paragraph">Därifrån fick Crescenzo Maione dirigera farten och mitt på upploppet stack han undan till en ohotad seger på 1.14,0/2.020 meter. Från tredje inner tog Collier (e. Maharajah) om andraplatsen och trea slutade Daniel Av (e. Noe d’Asolo) från rygg ledaren.</p>



<p class="wp-block-paragraph">Som treåring vann Ector Francis Grupp I-loppet Gran Premio Tito Giovanardi och han slutade även tvåa i det italienska Derbyt. Modern <strong>Pandaz di Mazval</strong> (e. Mr Vic), 1.12,4/€23.201, har också lämnat<strong> Brandy di Mazval </strong>(e. Napoleon), 1.13,7/€13.280.</p>
