
<p class="has-drop-cap wp-block-paragraph">1 <strong>Francesco Zet </strong>kommer ut igen, på V85 på Solvalla på lördag, precis innan barfotaförbudet träder i kraft i december och det är i Frances Bulwarks lopp med 250.000 kronor i förstapris han är med och börjar från bakspår. Den snart 26-faldige miljonären (25.706.500 kr) gör sin elfte start för året och har aldrig tidigare varit så flitig under en och samma säsong. Som treåring gjorde Francesco Zet tio starter innan han fyllde på med nio som fyraåring, fyra som femåring och åtta ifjol.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/3giftedkronos-617x333.jpg" alt="" class="wp-image-773019" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Gifted Kronos och Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Utanför V85-kupongen hamnade de treåriga stonas uppgörelse i Wallenius Cup med 150.000 kronor till vinnare. Daniel Wäjerstens Oaksfyra <strong>Gifted Kronos</strong> (e. Bold Eagle) är fältets mest meriterade deltagare och helt säkert är att <strong>Milady Josselyn</strong> (e. Ready Cash-Uza Josselyn) är det sto som kan skryta med rikast föräldrar.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/11/29v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Solvallas V85-omgång.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2018/10/christoffererikssonsulky-617x333.jpg" alt="trav, travsport, sulkysport, jägersro, champion" class="wp-image-31520" style="width:601px;height:auto"/><figcaption class="wp-element-caption">Christoffer Eriksson. Foto Jeannie Karlsson/Sulksport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2 Två spännande treåringar – i lindan av sina karriärer – dyker upp i varsitt lopp på <strong>Färjestad</strong> (första start 18.20) ikväll. För drygt två veckor sedan anlände italienska stoet <strong>Grodda Jet </strong>(e. Oasis Bi) till Christoffer Eriksson från Jeroen Engwerdas stall.</p>



<p class="wp-block-paragraph">Där gjorde hon en start som tvååring – femma på 1.14,5ak i Wolvega – men efter långt uppehåll var hon tillbaka i slutet av sommaren. Tre starter har slutat med två segrar och en andraplats. Vid senaste framträdandet kördes hon till ledning på första långsidan i Hamburg och vann enkelt på 1.15,9a/2.200 meter.</p>



<p class="wp-block-paragraph">Sedan dess har hon bytt ägare och köpts av Designalite 01 AB, Malmö, som därmed fyller på hästantalet hos Christiffer Eriksson. Fem hästar finns numera hos Åbytränaren. En av dem är fyraåriga<strong> Real Desire</strong> (e. Chapter Seven) som köptes för 250.000 kronor på Travera i början av oktober och har inlett med två raka segrar i Erikssons regi.</p>



<p class="wp-block-paragraph">Familjen Goop och Håkan Arvidsson har ett ämne i <strong>Prince Harry </strong>(e. Face Time Bourbon), som svarade för en härlig tävlingsdebut i juni. <em>”Det känns att han har mycket potential i sig, det är en fin individ. Han fick sträcka lite på sig, han kan springa jättefort”</em>, sade Björn Goop efteråt.</p>



<p class="wp-block-paragraph">Det har dock hackat lite i skivan, men intrycket vid segern i livets tredje start senast lovade gott. Nu är han på segerjakt igen från tillägg i ett treåringslopp.</p>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/05/kaptennemo-617x333.jpg" alt="" class="wp-image-722862" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Kapten Nemo och Peter G Norman. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3 Travveckan inleds med lunchtävlingar i <strong>Eskilstuna</strong> (start 12.20), dit anmälningsintresset var stort. Delningspropsitionen upp till miljonen intjänat delades upp i ett extra lopp och står för åtta tiondelar av dagens lopp. Dessutom ville 25 hästar vara med i nolloppet, som delades i två lopp.</p>



<p class="wp-block-paragraph">Till skillnad från de flesta delningspropositioner som avgörs som spårtrappor, så lottas startspåren i dagens lopp sedan hästarna delats in i respektive lopp.</p>



<p class="wp-block-paragraph">Peter G Norman-tränade <strong>Kapten Nemo</strong> (e. G.H.Nemo) har tjänat tredje mest pengar i sitt lopp, men lottats till fjärdespår bakom bilen istället för spår elva som det blivit i en spårtrappa. Det borgar för andra årssegern för hästen som i våras travade 1.10-tider två gånger på Solvalla.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4 Fredrik Wallins fyraåring <strong>Libellule</strong> (e. Golden Bridge) var totalt överlägsen vid seger i Prix du Palais du Tau (€18.000) i franska Reims under söndagskvällen. Anthony Barrier skickade Libellule till ledningen direkt på högervarvsbanan och sedan kunde ingen av motståndarna utmana. Barrier lät Wallins sto löpa undan över upploppet och segern blev mycket lätt på 1.15,9/2.550 meter.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/11/skarmavbild20251123kl.18.15.50-617x333.jpg" alt="" class="wp-image-796386" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Libellule var överlägsen i Reims.</figcaption></figure>



<p class="wp-block-paragraph">Libellule såldes till Fredrik Wallin för 14.000 euro vid auktionen i Deauville 2022 och hon hade två segrar sedan tidigare, tagna i oktober ifjol med tränare Wallin i sulkyn båda gångerna.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 MBDSBFF. <strong>Marv Bachard Delaware Standardbred Breeders Fund Final </strong>($110.000) för tvååriga ston avgörs på Dover Downs i Delaware i kväll och loppet saknar helt svenska inslag. Kuskeliten i Grand Circuit-racen saknas också, men en tvååring i jakt på sjätte raka segern finns med i fältet med åtta deltagare. Corey Callahan, mest känd för oss nordbor som kusken bakom Googoo Gaagaa, sitter upp bakom favoriten <strong>Tuis Star</strong> (e. E L Platinum) och David Wests sto är en av tre hästar som överhuvudtaget vunnit lopp så här långt i karriären.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/11/skarmavbild20251123kl.20.29.40-617x341.png" alt="" class="wp-image-796385" style="width:677px;height:auto"/></figure>



<p class="wp-block-paragraph">Om det är tränarna eller kuskarna som är oroliga över hur deras respektive hästar ska sköta sig ska vi låta vara osagt, men att sju av åtta deltagare tävlar med ”trotting hopples”, alltså hjälpmedel för att hålla sig i rätt gångart, ger inget plusbetyg åt evenemanget. Likväl ska 110.000 dollar fördelas.</p>



<p class="wp-block-paragraph"><strong>Startlista</strong><br><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>Tuis Star (e. E L Platinum) – David West</li>



<li>Suburban Lady (e. Glidemaster) – Dylan Davis</li>



<li>Angelic Valentine (e. Top Flight Angel) – Les Givens</li>



<li>Belle’ Natania (e. E L Platinum) – William Wyatt</li>



<li>Rainingrainbows (e. Glidemaster) – Robert Shawn</li>



<li>Wolfpack One (e. E L Platinum) – Jason Skinner</li>



<li>Sheas Bluestone (e. Anders Bluestone) – Mark King</li>



<li>Emerys Angel (e. Top Flight Angel) – Stacy Johnson</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6 <strong>Kajsa Larelius</strong>, anställd hos Jörgen Westholm, är i ensam ledning i skötarligan inom STL 2025. Hennes passhästar <strong>Jobspost</strong> och <strong>Castor The Star</strong> har fört henne till toppen och hon ståtar med totalt nio STL-segrar.</p>



<p class="wp-block-paragraph"><strong>Saga Scott</strong> (Adrian Kolgjini) har även hon haft ett starkt år som skötare. <strong>Savastano</strong> har tagit hem tre lopp medan <strong>Gudrid Face</strong> fått ihop fyra. </p>



<p class="wp-block-paragraph">Trea i ligan är <strong>Johanna Nordin </strong>(Daniel Wäjersten), <strong>Therese Bergh</strong> (Robert Bergh), <strong>Felicia Lindström</strong> (Maria Törnqvist) och <strong>Anu Niskanen</strong> (Alessandro Gocciadoro, alla med sex skötarvinster var.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/07/castorthestarmal-617x333.jpg" alt="" class="wp-image-616236" style="width:428px;height:auto"/><figcaption class="wp-element-caption">Castor the Star och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Proffstränare som plockat skötarsegrar under året är bland andra <strong>Maria Törnqvist,</strong> tre vinnare, <strong>Anders Wallin</strong>, tre vinnare, <strong>Fredrik Wallin</strong> med två vinnare och…<strong>Björn</strong> <strong>Goop</strong>, en vinnare.</p>



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



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/11/wb111525r3mmsdream-617x346.jpg" alt="" class="wp-image-793415" style="width:677px;height:auto"/><figcaption class="wp-element-caption">M-m&#8217;s Dream vinner för Yannick Gingras. Foto: Lisa Photo</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7 <strong>M-M’s Dream</strong> (e. Swan For All-Trading Places) har avslutat sin tävlingskarriär. I lördags, på Hoosier Park gjorde den sexåriga dubbla dollarmiljonären sin sista start och M-M’s Dream går i pension som den näst vinstrikaste travaren någonsin från staten Indiana, med Hannelore Hanover framför sig i den listan.</p>



<p class="wp-block-paragraph">M-M’s Dream vann 37 lopp på 70 starter och tjänade 2.296.762 dollar och bland hennes största segrar räknas tre finaler i Indiana Sire Stakes, Steele Memorial, Miss Versatility (två gånger), samt The Hambletonian Maturity. Henry Graber Jr är tränaren som managerat M-M&#8217;s Dream på sistone.</p>



<p class="wp-block-paragraph">Chapter Seven förväntas bli hennes första partner i avelsboxen.</p>
