
<p class="has-drop-cap wp-block-paragraph">Duon Timo Nurmos och Mattias Djuse prenumererar på segrar vecka in och vecka ut och har alla möjligheter att få ännu en framgångsrik lördagseftermiddag tillsammans.</p>



<p class="wp-block-paragraph">Duon står bakom båda våra spikar då vi bedömer <strong>Excusez Moi</strong> (V75-1) som sannolik anförare av Bronsdivisionen från start till mål samt <strong>Erik the Phantom</strong> (V75-5) som &#8221;för bra&#8221; för sina konkurrenter i Klass I-försöket.</p>



<p class="wp-block-paragraph">Med Admiral As som huvudrollsinnehavare av Gulddivisionen har det loppet placerats utanför V75-spelet och istället ersatts med en spårtrappa (V75-2). Vi tycker att en trio sticker ut i det loppet, men betalar istället för sju av 14 deltagare i ett lärlingslopp och tio av de 15 i ett vidöppet stolopp. De loppen gör att det verkligen finns potential för anständig utdelning!</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/09/16v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna i Eskilstuna.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-09-16_14_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-09-16_14_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-09-16_14_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Bronsdivisionen, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Excusez Moi </strong>var bara dryga längden efter vinnaren Danger Bi i Eskilstunas Fyraåringstest och höll mycket bra som tvåa bakom Don&#8217;t Say Gar i den efterföljande starten. Han fick ett tufft upplägg i derbykvalet och gjorde en stark insats även om den bara utmynnade i en sjätteplats. Från innerspår i volten är spetschansen mycket god och från den positionen bör han bli mycket svårslagen.</li>



<li><strong>Dylan Dog Font </strong>tror vi är en lika bra häst, men däremot är vi tveksamma till hur han kommer hantera det snäva startspåret. I Italien har hästen antingen galopperat från start i gällande startmetod eller att det gått som på nålar och svensk voltstart är betydligt mer utmanande än vad den italienska motsvarigheten får anses vara. Kapacitetsmässigt är hästen jättebra och sättet han sköt till på vid segern i Sverigedebuten lovade mer, men vi oroar oss som sagt för just spår två i volten.</li>



<li><strong>Olga Utca</strong> gick jättebra mot elithästarna i Smålandsmästaren som trea och sköt därefter till riktigt vasst som Stoeliten-femma efter passivt upplägg. Vanlig vagn är inget minus för henne, men däremot är det inte optimalt att hon nu ska tävla med skor på hovarna.</li>



<li><strong>Filippa B.J. </strong>fick chansen för sent senast på Solvalla för att hinna utmana, men gick med bra fart över mål. Hon har tjänat mer pengar än hingstarna i denna Bronsdivision då ston har propositionsmässig fördel och är en utmanare bakspår till trots.</li>



<li><strong>Parveny</strong> sprang inte in 711.500 kronor på tur under fjolåret, men vi förväntar oss inget offensivt upplägg här när han gör comeback efter närmare fem månaders tävlingspaus.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-2 <strong>B: </strong>2-9-10-6-3-7 <strong>C: </strong>5-4-8-12-11</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Det föreligger sannolikt stor galopprisk för <strong>Dylan Dog Font</strong> från spår två medan <strong>Excusez Moi </strong>öppnade riktigt snabbt vid sitt senaste försök från spår ett. Även om springspårshästarna skulle komma förbi bör chansen att han kan vikas ut och överta taktpinnen i tidigt skede vara god.</p>



<h2 class="wp-block-heading">Avd 2 – Spårtrappa, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Portofino</strong> väljer vi att ge tipsnicken till i ett lopp där en trio helt klart sticker ut. Han har tävlat i spårtrappor och från just tredje ledet i två av sina tre senaste starter och då stått för toppinsatser efter offensiva upplägg. Senast galopperade han från start i derbykvalet, men kom tillbaka starkt som femma via 1.12,2 sista 2.500 meterna. Den dagen tävlade han med skor, men nu blir det barfota bak vilket vi ser som ett klart plus.</li>



<li><strong>It&#8217;s Peppertime </strong>får starta vecka-vecka efter att galopperat bort sina chanser direkt från start i lördags i Bollnäs. Han stod för en strålande insats som dödenstrea i derbykvalet gången innan, men då tävlade han barfota runt om och den balansen tycks inte vara aktuell i det här loppet. Totalt sett är dock inte uppgiften tuffare än han att han ska ses som en faktor och segerkandidat även om det blir skor runt om.</li>



<li><strong>Luv You Schermer</strong> hade varit strålande bra vid segerloppen, men senaste insatsen var ett litet steg tillbaka då vi tycker det ebbade ut väl mycket sista 100 meterna. Nu växlar man upp med barfotabalans samt jänkarvagn vilket är plusfaktorer, men det kan bli tufft att komma fram från spår åtta bakom bilen.</li>



<li><strong>Brasco Brodde </strong>fick jaga från tredje utvändigt senast och gjorde det berömvärt som tvåa via 1.12,7 sista varvet. Han är klart bättre än resultatraden antyder och kan komma till fint direkt på startsnabbhet trots spår sju.</li>



<li><strong>Bold Face </strong>spurtvann ett Stochampionatsförsök från femte utvändigt och är stark, men uppgiften är inte enkel när hon inleder i tredje ledet mot hingstar och valacker.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>13-15-8 <strong>B: </strong>7-14-9-6-3-5-1-2 <strong>C: </strong>12-4-10-11</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Ruffian utmanas av <strong>Gasparito</strong>, <strong>Furiosa</strong>, <strong>Angel of Trix</strong> och <strong>Brasco Brodde</strong>. Vi kan se ett scenario där Furiosa är raskast och överlåter täten till Brasco Brodde i nästa skede, men här är inget hugget i sten.</p>



<h2 class="wp-block-heading">Avd 3 – Klass II, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Perkins</strong> blir vårt tipsval i detta lopp där det sannerligen inte är några nykomlingar som gör upp i klassen utan sju av de tolv deltagarna har testat i Klass II-försök tidigare. Nuncio-sonen kommer från en stark avslutning från tredje utvändigt i försöket som avgjordes på Bergsåker och rekordsänkte med närmare två sekunder. Gången innan var han väldigt övertygande då han vann från ledningen på Solvalla, men vi ser inte den positionen som ett måste för hans del utan nu när han är under kraftigt utveckling har han chans att vinna flera olika vägar.</li>



<li><strong>Ringo Adore</strong> var också med i Klass II-försöket på Bergsåker. Han tog ner ledaren från dödens, men gick sig trött sista 150 meterna och mattades rätt så rejält. Gången innan tog han emot derbyfinalisten Working Class Hero länge och väl och även om Ringo Adore varit riktigt bra vid de två senaste starterna så kan det vara så att de tuffa loppen nu kan börja sätta sina spår.</li>



<li><strong>Sparky&#8217;s Dream </strong>var &#8221;surrhäst&#8221; i lördags efter två övertygande Bollnästriumfer i enklare omgivning. Då blev han dock stressad efter omstarter och galopperade direkt. Anders Eriksson laddar snabbt om med sin Maharajah-son som verkar tuff och förmögen att hävda sig även med grovjobb.</li>



<li><strong>Natural Mine </strong>fick se sig sönderpressad av Ringo Adore senast på Bergsåker och verkade slagen när galoppen kom 250 meter före mål. Frågan är hur Jörgen Westholm gör taktiskt denna gång om han håller ut samme konkurrent initialt?</li>



<li><strong>Star Cash</strong> tycker vi var riktigt bra senast som V75-tvåa under derbydagen där han bet i med 1.12 sista varvet och gick hela vägen &#8221;in i säcken&#8221;. Hästen må bara räknat hem en seger såhär långt i karriären på 18 försök, men vi tycker han är så pass uppåt nu att han är värd att betala för.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>7-2 <strong>B: </strong>4-1-6-10 <strong>C: </strong>11-9-3-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Natural Mine </strong>utmanas av<strong> Ringo Adore</strong>. Vi tror främst på Ringo Adore som anförare, men det är långt ifrån givet.</p>



<h2 class="wp-block-heading">Avd 4 – Lärlingslopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Ferox Brick </strong>blir vårt tipsval i detta öppna lärlingslopp. Han har gjort två starter efter långt tävlingsuppehåll och gått riktigt bra båda gångerna. Första tillfället fick han jaga från sjätte utvändigt och stod för en urstark slutrunda och senast så höll han farten väldigt bra via vinnarhålet efter att utmanat Haitkin Am på utsidan sista halvvarvet. Prickar Marcus Lilius från springspår och når ledningen kan loppet vara över.</li>



<li><strong>Future Sox </strong>var åter mycket positiv senast på Bergsåker efter en riktig downinsats gången innan på Romme. Hon fick långt fram från femte utvändigt, men avslutade jättebra som tvåa 1.12,2 sista varvet och svarade bestämt när det norska huvudlaget nyttjades. Den här gången ska stoet tävla barfota runt om igen (trea, fyra samt sexa i tidigare försök) och ger det en skjuts till så är hon en faktor oavsett om det blir ledningen eller ett rygglopp.</li>



<li><strong>Bara du Chene </strong>har återfunnit formen med besked. Han fick gnugga på som förstahäst i tredjespår de sista 700 meterna senast på Axevalla, men tog striden och avgjorde med knapp marginal via 1.10,8 sista 700 meterna. Julia Nilsson uppfattar vi som en cool kusk som inte förivras sig i onödan.</li>



<li><strong>Extreme A.F. </strong>kördes fram i dödens efter ett varv senast på Åby, men frågan är om han inte passar bättre med rygglopp. Den här hästen är oerhört härdad i lördagslopp och nu ska han testas barfota runt om för blott andra gången. Vid föregående försök blev det galopp, men det var så långt tillbaka som år 2021.</li>



<li><strong>Without A Doubt </strong>blir nog loppets &#8221;surrhäst&#8221; efter en hiskelig upphämtning á 1.11 sista 2.000 meterna senast. Han gick med bra fart hela vägen in till mål, men visa av erfarenhet så vet vi att de där upphämtningarna inte alltid träffar helt rätt i slutänden utan att det kan komma ett bakslag i efterföljande start.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>7-6-13-2 <strong>B:</strong> 12-4-5-3-8 <strong>C: </strong>1-11-14-9-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Minou Båven </strong>får svårt att hålla ut springspårshästarna där vi tycker det är knapp fördel för <strong>Ferox Brick</strong>.</p>



<h2 class="wp-block-heading">Avd 5 – Klass I, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Erik the Phantom </strong>besegrade riktigt bra kullkamrater i ett Breeders Crown-försök i Örnsköldsvik i september, men därefter dröjde det till juli i år innan nästa start kom. Han slog på en galopp i tidigt skede den gången och hade därför inget lopp i kroppen inför derbykvalet och utifrån det tycker vi att han höll bra som fyra efter att gått i dödens sista 1.600 meterna. Tar hästen det loppet på rätt sätt så har han chans att lösa denna uppgift även om det så blir till att nöta utvändigt ledaren på nytt.</li>



<li><strong>Mud Hill </strong>är den mest sannolika anföraren av det här loppet även om det finns raska utmanare på utsidan. Han flög till tät i derbykvalet innan Thomas Dalborg släppte ledningen och hakade på fullt godkänt som femma. Senast på Jägersro gick han en rejäl långspurt till andraplatsen bakom Joint Chef som stod på startvolten. Nu växlas det upp med jänkarvagn och håller man upp innerspåret så lär Father Patrick-sonen köras i tät.</li>



<li><strong>Solöns Skrammel </strong>har gjort två toppinsatser i följd från ledningen varav den senaste kom i just denna klass. Att det är anmält skor runt om nu är ett litet minus och vi kan också se Rikard N Skolgund vika ner bakom Mud Hill och samla på sig viktiga STL-poäng för att nå finalen istället för att vara superoffensiv.</li>



<li><strong>Fetter Tif </strong>höll bra från dödens bakom Mercenary senast på Bergsåker och tycks uteslutande göra rejäla insatser. Blir loppet överpacat kommer han in i matchen.</li>



<li><strong>Dubbio Amletico</strong> avslutade 1.12 sista varvet från köposition senast i Klass I och är lite Fetter Tif ett objekt för den som söker skrällstreck i tro om att det blir överpacat och de mer betrodda faller på eget grepp.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>4 <strong>B: </strong>1-2-10-5-11-6-8-7<strong> C: </strong>3-12-9</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Mud Hill </strong>har god chans att hålla ut <strong>Solöns Skrammel</strong> samt<strong> Mister Lucky Sox</strong> när de står sida vid sida.</p>



<h2 class="wp-block-heading">Avd 6 – Diamantstoet, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Lilly Avant </strong>har lyft sig markant i de fyra senaste starterna. Näst senast spetsade hon och vann lekande lätt via 1.12,5 sista varvet och senast på Bergsåker så gick hon en häftig långspurt via 1.11 sista varvet och tog striden hela vägen hem till mållinjen. Lyckas Erik Adielsson få henen att hålla upp innerspår i volten kan loppet vara över.</li>



<li><strong>Mi Amore Bros </strong>sprang undan på lätta hovar framme i tät i Derbysto-kvalet, men slog på en galopp i vinnarhålet efter 200 meter i finalen. Hon har precis som vår tipsetta höjt sig ordentligt under sensommaren och går inte räkna bort trots spår tolv i volten och risk för en bynglig väg fram.</li>



<li><strong>Nunja</strong> gillade vi vad vi såg av vid spurtsegern på Axevalla och hon har på intet vis varit dålig i efterföljande starter heller. Det är en smula svårbedömt hur hon ska komma till här från springspår, men blir det inte allt för vingligt initialt så är hon med och strider om segern.</li>



<li><strong>Urbina Southwind </strong>stod emot Lilly Avant senast efter häftig forcering till tät mitt i loppet. Hon var knallbra, men det faktum att hon ska tävla i vanlig sulky nu samt eventuellt skor runt om är ett litet minus.</li>



<li><strong>Global Delight </strong>vann enkelt från ledningen senast i Eskilstuna och det är inte alls säkert att hon är så mycket sämre än stallkamraten Mi Amore Bros som är klart mer spelad.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-12 <strong>B: </strong>7-10-11-3-8-5-2-14 <strong>C: </strong>15-4-6-9-13</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Lilly Avant </strong>är rask ur groparna och har toppchans att hålla ut Rosemary Tile samt springspårshästarna vilka vi ser som de värsta utmanarna.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Comes With Age</strong> har vunnit två Silverdivisionslopp på tider under 1.10 under sommaren och är mycket svår att frångå i tipsvalet trots att han möter &#8221;överkvalificerade&#8221; ston. Sexåringen var strålande bra sneast på Bergsåker då han höll stången trots en öppning på 1.05,5 första halvvarvet och varvpassering på 1.09,5. Även om det finns många startsnabba hästar med i det här loppet så talar det mesta för att han frontar från innerspår bakom bilen och då ska han normalt sett bli väldigt svårslagen.</li>



<li><strong>Iceland Falls</strong> har härdats i stentuffa gäng hela året. Hon kommer närmast från en femteplats i European Championship for Mares där hon spurtade bra i skymundan och var dessförinnan tvåa i Gulddivisionen i Visby. Att komma förbi Comes With Age av egen kraft blir svårt, men väljer Magnus A Djuse att droppa ner bakom kan stoet få rena drömresan i draget.</li>



<li><strong>Dear Friend </strong>är en evighetsmaskin som aldrig tycks sluta springa. Hon har redan vunnit Stoeliten under detta år och gör nu högintressant debut i Daniel Wäjerstens regi. Spår sju är inget drömläge och start i Sto-SM lär stunda härnäst om två veckor, men skulle Orlando Vici-dottern komma ner i vettigt läge är det ingen som går säker för henne i spurten.</li>



<li><strong>Callisto</strong> var otroligt tapper senast på Jägersro som tvåa efter att gått i tredjespår hela vägen utan rygg! Det var en ruskigt vass prestation, men vi tycker ofta att hästar som fått ett sådant upplägg tar ett steg tillbaka till nästa lopp och behandlar Callisto lite reserverat.</li>



<li><strong>Laradja Vrijthout </strong>var riktigt positiv senast på Solvalla där han gick runt fältet sista 700 meterna i tredjespår. Han har varit rusarbetonad tidigare, men det kan vara så att han är på väg att bredda sitt register nu. </li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-2 <strong>B: </strong>7-9-6-8-5 <strong>C: </strong>3-11-10-4-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Comes With Age </strong>har stor fördel att komma till ledningen gentemot <strong>Iceland Falls</strong>, <strong>Bravo Sabotage</strong> och<strong> Laradja Vrijthout </strong>när han har spår ett.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 16 SEPTEMBER								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1 Excusez Moi (2,9)<br><strong>Avd 2: </strong>8,13,15 (7,14)<br><strong>Avd 3:</strong> 1,2,4,6,7,10 (11,9)<br><strong>Avd 4:</strong> 2,4,5,6,7,12,13 (3,8)<br><strong>Avd 5:</strong> 4 Erik the Phantom (1,2)<br><strong>Avd 6: </strong>1,2,3,5,7,8,10,11,12,14 (15,4)<br><strong>Avd 7: </strong>1,2,7 (9,6)</p>



<p class="wp-block-paragraph"><em>3.780 rader / 1.890 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
