
<p class="has-drop-cap">Det är Unionstrav som gäller på Färjestad denna vecka, men intresset från vårt västra grannland har varit klart begränsat.<br>Bortsett från kallblodens Unionskampen så ekar det närmast tomt med norskt deltagande vilket åtminstone gör att att det är mer bekanta, svenska hästar som spelarna får arbeta med i sina bedömningar.</p>



<p>Vi spelar som så många gånger tidigare med två singelstreck på V75-spelet. <strong>Notice&#8217;em</strong> (V75-4) tycker vi är värd att ta ställning för i Diamantstoet då det är mycket som talar för att hon vinner starten och kan spåra hela vägen.</p>



<p><strong>Lozano di Quattro</strong> (V75-7) var enorm vid seger i Bronsdivisionen i senaste starten och allt talar för att han kommer gå som en raket rakt upp till Gulddivisionen.</p>



<p>Vi tror på ny seger för honom, men garderar däremot segermaskinen <strong>Tangen Bork </strong>(V75-6) i Unionskampen som vi kan se få en för tuff resa denna gång för att det ska bära hela vägen fram till ny vinst.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/09/23v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Färjestad.</a></p>



<p><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



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



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



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



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



<ul class="wp-block-list">
<li><strong>Always A Pleasure</strong> spurtade strålande bra i Klass II-finalen på Åby och frågan är om han inte hade vunnit sitt Klass I-försök senast i Bollnäs utan galopp. När 250 meter återstod slog han på felstegen på väg utåt i banan för attack och med tanke på att Västerbo Ajax nu istället avgick med segern som satt bakom honom så kan vi inte tro annat än att Always A Pleasure missade segern på sina felsteg. Femåringen är inte helt att lita på och galopperade kort efter start i sitt senaste voltlopp, men ska ha toppchans att vinna detta lopp vid felfri avgång.</li>



<li><strong>Jimbaran Zon</strong> kommer från seger trots galopp i första kurvan. Han reparerade strålande via 1.13 sista 2.400 meterna och stod för en häftig svepning över sista bortre långsidan. Denna gång är hästen anmäld barfota runt om, men han har faktiskt aldrig vunnit på den balansen utan felat i fyra av sex försök.</li>



<li><strong>In Love Mearas </strong>fick se sig regelrätt nedplockad av en bättre häst på Romme, men gick en bra långspurt senast i Mantorp som tvåa via 1.11,8 sista varvet. Han är jämn och stabil som få andra och hade varit snäppet högre upp i vår rank om han inte hade haft en startrygg vars startsnabbhet tycks vara begränsad.</li>



<li><strong>Global Delayed </strong>avgjorde ett ganska billigt lopp från dödens, men gjorde det på rätt sätt. Han spurtade till vinst via tredje invändigt i ett Klass II-försök i juni och är vass om han får spara speeden.</li>



<li><strong>Solöns Skrammel </strong>felade från start i lördags, men har dessförinnan gjort två mycket starka insatser från ledningen. Kan hon nå dit denna gång från springspår är det inte omöjligt att hon säljer sig dyrt på den självspringande Färjestadovalen.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A:</strong> 2 <strong>B: </strong>7-8-9-6-3-12-10 <strong>C: </strong>1-11-4</p>



<p><strong>Spetsstriden: Ever So Much</strong> tappade mycket mark från innerspår i sitt senaste försök från det läget och <strong>Always A Pleasure</strong> galopperade efter 100 meter i sitt senaste voltlopp. Här är spetskampen mycket ovis, men vi bedömer <strong>Solöns Skrammel </strong>som knapp spetsfavorit före<strong> Vision of Gideon</strong>.</p>



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



<ul class="wp-block-list">
<li><strong>Going Cash</strong> lär bli haussad i kvadrat i det här loppet och vi motsätter oss inte det. Han var jättefin vid de två spetssegrarna i somras och satt fast med rubbet sparat bakom Mondriaan Boko i Klass II-försöket på Jägersro efter att vikts ner där bakom efter ett halvvarv. Ready Cash-sonen har uppvisat en god startsnabbhet och skulle han rentav kunna forceras hela vägen fram till tät så blir han svårfångad.</li>



<li><strong>Joint Cheif </strong>vann ett 100.000 kronorslopp på Jägersro under derbyhelgen efter att anfört från start till mål och avslutat 1.12,3 sista varvet. Gången innan fick han för långt fram i samma lopp som Going Cash gick segrande ur striden ur och var chanslös att utmana om segern då han fick ett klart tuffare lopp. Vi gillar den här Muscle Hill-sonen, men frågan är hur han hamnar till från innerspår bakom bilen?</li>



<li><strong>Lipton Scott </strong>höll bra som spetstrea på Solvalla i juni trots en 1.09-öppning. Han fick en tävlingspaus på två månader efter det och gick en rejäl slutrunda i comebacken på Åby om än mot ganska beskedlig konkurrens. Med det loppet i kroppen lär han vara ytterligare förbättrad till denna start och den dryga distnasen ser vi bara som ett plus för hans del.</li>



<li><strong>Tom&#8217;s Got Drive</strong> fick se sig regelrätt besegrad från ledningen på Romme mot hästar som helt enkelt var för bra, men revanscherade sig snabbt då han vann från dödens på Solvalla via 1.12 sista 800 meterna. Han är knapp spetsfavorit då startsnabbheten på Joint Chief är osynad, men vi är ändå lite tveksamma till om man kör i den positionen över lång distans om favoriten utmanar.</li>



<li><strong>Re Public </strong>fungerade inte på barfotabalans i senaste starten utan galopperade dubbelt. Gången innan satt han fast med sparade krafter bakom Going Cash och vi tycker att den här fyraåringen är klart bättre än vad spelarkollektivet verkar anse.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>5 <strong>B:</strong> 1-10-4-7-3-8 <strong>C: </strong>6-11-12-9</p>



<p><strong>Spetsstriden: Joint Chef </strong>har aldrig varit nära att ha ett sådant här startspår och hans startsnabbhet är närmast omöjlig att bedöma<strong>. Tom&#8217;s Got Drive</strong> bör ta sig förbi de två hästarna han har på sin insida, men utifrån utmanar<strong> Going Cash </strong>som kan se få överta över lång distans.</p>



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



<ul class="wp-block-list">
<li><strong>Mellby Jinx</strong> stod för en toppinsats vid segern i Gulddivisionen i Bollnäs. Då fick han trava sista 800 meterna utan rygg i tredjespår, men det spelade ingen roll utan han brottade ner sina konkurrenter bestämt och höll emot Axel Ruda i slutskedet. Oavsett hur det taktiska upplägget blir här så har Mellby Jinx alla möjligheter att vinna och vi håller honom högst av de tre hästar som vi tror loppet står mellan.</li>



<li><strong>Missle Hill</strong> vaknade verkligen till under sommaren med andraplats i Årjängs Stora Sprinterlopp, seger i Gotlandslöpning och tredjeplats i Sundsvall Open Trot. I det sistnämnda loppet blev han egentligen tempotorsk och det var starkt gjort att hinna fram till bronset. Missle Hill är spetsfavorit, men vi behandlar ändå honom med viss skepsis över full väg och kan se honom bli nerplockad.</li>



<li><strong>Charmant de Zack</strong> var otroligt bra på Romme då han vände ut och in på sina konkurrenter via en häftig långspurt. Han fick starta redan sju dagar senare och då hamnade han för långt bak i Sundsvall Open Trot och fick nöja sig med sjätteplatsen. Nu blir det fyra veckor mellan loppen vilket kan vara gynnsamt och presterar han på samma nivå som på Romme går ingen säker för honom.</li>



<li><strong>Night Brodde </strong>var klart positiv senast på Jägersro, men från spår åtta över full väg ser vi ändå inte fjolårets Elitloppsfinalist som ett glödhett bud.</li>



<li><strong>Diamanten</strong> sköt till riktigt bra som tvåa i Gulddivisionen på Dannero, men felade från start gången efter. Tioåringen skulle kunna dyka ner i vinnarhålet här precis som vid starten i Kramfors och bärga en platsplacering den vägen.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>7-3-6 <strong>B:</strong> 8-4<strong> C: </strong>5-1-2</p>



<p><strong>Spetsstriden: Missle Hill </strong>har god chans att hålla ut <strong>Diamanten</strong> när de står sida vid sida. <strong>Mellby Jinx </strong>och <strong>Night Brodde</strong> är båda vrålraska vid laddning, men vi ställer oss tveksamma till om de vil lägga den speeden över full väg.</p>



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



<ul class="wp-block-list">
<li><strong>Notice&#8217;em</strong> tycker vi står inför en mycket lämplig uppgift i detta Diamantstoförsök där det inte kryllar av damer som visat knallform i de senaste starterna. Daniel Redéns sto tappade förvisso lite från tredje invändigt senast i ett tufft kval till Derbystoet, men var rejäl vid segern på Hagmyren gången innan efter forcering till tät mitt i loppet och vann även väldigt enkelt från den positionen på Sundbyholm i slutet av juni. Från ett utsökt innerspår är spetschansen god och sedan är det &#8221;bara&#8221; för Magnus A Djuse att hålla farten uppe så pass att tilläggshästarna får det för svettigt.</li>



<li><strong>Global Collection</strong> tillhör den jagande skaran 20 meter bakom. Hon forcerades fram i dödens inför slutrundan i just ett Diamantstoförsök för tre veckor sedan och hade avgjort loppet redan halvvarvet före mål. Hon är i toppslag, men har tidigare haft en viss tendens att falla ifrån efter några starkare insatser och frågan är hur offensiva man vill vara nu när Diamantstofinalen stundar om tre veckor?</li>



<li><strong>Loaded Leila</strong> har en hög högstanivå, men vi var aningen besvikna på henne senast på Solvalla även om hon mötte riktigt bra hästar. Lyckas Markus B Svedberg packa in henne med ett vettigt rygglopp och spara speeden ska hon normalt sett duga bra i ett sådant här sällskap.</li>



<li><strong>Dior Lilly</strong> fick för långt fram senast i Örebro från fjärde utvändigt, men avsluade starkt via 1.11,8 sista varvet. Med bara tre hästar på startvolten tror vi att Carl Johan Jepson jobbar för en snabb start och position långt fram i fältet per omgående.</li>



<li><strong>Nelsonbrighteagle </strong>vann ett Diamantstoförsök i Lindesberg i juni, men har haft galoppskorna på sig i de två senaste starterna. Nu återkommer hon efter en och en halv månads uppehåll och känns allmänt svårbedömd.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A:</strong> 1-4 <strong>B: </strong>7-10-11-2-13-3 <strong>C: </strong>15-14-9-12-5-6</p>



<p><strong>Spetsstriden: Notice&#8217;em </strong>närmast skenade iväg från spår ett vid voltloppet i Eskilstuna i slutet av juni och har dunderchans att fronta.</p>



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



<ul class="wp-block-list">
<li><strong>Blackflash Bar</strong> har inte tävlat i så här pass överkomlig omgivning &#8221;sedan Sundsvall brann&#8221;, men det innebär inte per automatik att hon går segrande ur striden. Det tungt meriterade stoet som bland annat besegrat Prix d&#8217;Amerique-vinnaren Hooker Berry övertygade stort vid de två inledande segrarna i Alessandro Gocciadoros regi, men det var inte alls samma tryck i henne i European Championship for Mares och efteråt uppdagades det att hon var nedsatt av halsinfektion. Nu låter det positivt inför återkomsten, men spår tolv är inte det enklaste och vi kan se konkurrenter vara intresserade av att &#8221;bråka&#8221; och göra vägen fram till dödens krävande.</li>



<li><strong>Ture L.A. </strong>har en hög högstanivå, men vi vill ändå säga att han var bättre än någonsin i senaste starten. Då dundrade han till tät från spår sex, höll ångan uppe och var helt ensam på banan på urstarka 1.11,4a/2.140 meter. Lyckas Johan Untersteiner skicka honom till tät på nytt så kan det hålla hela vägen igen.</li>



<li><strong>Imperatur Am </strong>satt fast med sparade krafter i Margareta Wallenius-Klebergs Pokal. Han forcerades till tät halvvägs in i ett stayerlopp under den norska derbydagen, men fick lite oväntat se sig passerad 25 meter före mål av stallkamraten Orlando Young. Studsar han tillbaka och presterar på sin högstanivå så hävdar sig Harper Hanovers-trean väl, men senaste insatsen lämnade som sagt en del övrigt att önska.</li>



<li><strong>Versace Face </strong>spurtade fullt godkänt bakom Castor the Star i senaste starten, men nu blir det sju veckor mellan loppen. Hästen är anmäld att tävla med jänkarvagn vilket blir andra gången i karriären efter ett misslyckat försök á startgalopp ifjol.</li>



<li><strong>Callisto</strong> var heroisk som silvertvåa trots tredjespår hela vägen på Jägersro och avslutade strålande i skymundan i lördags. Nu blir det täta starter och spår sju innebär vingelrisk, men att Carl Johan Jepson svingar sig upp i sulkyn istället för Salvatore Luongo är ett gigantiskt plus.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>12-5-6 <strong>B: </strong>4-7-3-1-8 <strong>C: </strong>2-9-10-11</p>



<p><strong>Spetsstriden: </strong>Innerspår är inte bra på Färjestad och vi tror att <strong>Laredo Boko</strong> får svårt att hålla ut <strong>Ture L.A.</strong></p>



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



<ul class="wp-block-list">
<li><strong>Tangen Bork</strong> har inte radat upp segrar via tur utan är normalt sett bäst när de norska och svenska kallbloden drabbar samman. Merparten av segrarna är tagna från ledningen och när han fick gå i dödens på Jarlsberg i juli så var det med knapp marginal som han avgjorde gentemot Troll Solen som var nära att kontra på insidan. Den dagen var det sprinterdistans och skulle nu Tangen Bork få vandra på ledarens utsida över full väg så är vi långt ifrån säkra på att han löser uppgiften.</li>



<li><strong>Järvsöodin</strong> är i sitt livs form och har bara blivit bättre och bättre ju längre säsongen har lidit. SM-segern bärgades via en knalltuff slutrunda och Järvsöfaks-sonen tog striden hela vägen in till &#8221;säcken&#8221;. Oavsett om han kan hålla ut B.W.Sture eller hamnar bakom så kommer han sitta fint till här och då har han alla möjligheter att ge Tangen Bork en rejäl match om segern.</li>



<li><strong>B.W.Sture</strong> galopperade innan start i SM, men kom tillbaka starkt som fyra. Hästen har stundtals agerat osäkert när han varit i &#8221;för bra form&#8221;, men håller han sig på mattan nu och vinner starten så kan han bli riktigt svårtuggad.</li>



<li><strong>B.W.Rune </strong>inledde året strålande och gick bra som fyra i Elitkampen, men därefter har det varit sämre prestationer. Studsar han tillbaka är han outsiderduglig.</li>



<li><strong>Grisle Odin G.L. </strong>hann fram med knapp marginal efter en stark avslutning senast på Bjerke och visade härlig form. Han var dödenstvåa bakom Tangen Bork näst senast och går inte räkna bort helt.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>7-2-3 <strong>B: </strong>6-4-8-1 <strong>C: </strong>9-10-5</p>



<p><strong>Spetsstriden: </strong>Det blir tufft för <strong>Tangen Trygg </strong>att fronta från innerspår på Färjestad med raske<strong> B.W.Sture </strong>på utsidan. Vi tror bestämt att man väljer att köra honom i ledningen även vid utmaning av <strong>Tangen Bork</strong>.</p>



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



<ul class="wp-block-list">
<li><strong>Lozano di Quattro </strong>har slagit ut i full blom under sensommaren och början av hösten. Efter att stått för en toppinsats som tvåa bakom Francesco Zet på Solvalla den 1 augusti så vann han ett försökslopp i Solvallaserien via en häftig långspurt bara för att följa upp det med en Bronsdivisionskross där han löste uppgiften trots att han fick nöta tredjespår hela loppet! Den här femåringen är häftig och kommer tveklöst vandra vidare upp till Gulddivisionen vad det lider. Det stundar en bronsfinal, men den är först om tre veckor så det bör inte bli &#8221;superpassivt&#8221; upplägg här från smaskigt utgångsläge samtidigt som värsta motståndaren finns i andra ledet.</li>



<li><strong>Excusez Moi </strong>trodde vi hårt på i lördags, men då blev han snuvad på ledningen från innerspår i volten och hamnade som trea längs sargen. Magnus A Djuse sökte fritt utåt i banan med hästen de sista 150 meterna, men fick aldrig utrymme för att spela ut hästens krafter utan Excusez Moi gick i mål med rubbet sparat. Fyraåringen är bra och blir normalt sett favorit i den här klassen, men nu möter han troligtvis en konkurrent som är för bra om båda maxpresterar.</li>



<li><strong>Pure Muscle </strong>var rejäl vid dödenssegern på Bergsåker och följde upp det med en säker spetstriumf på Solvalla. Han brukar trivas allra bäst i just ledningen och även om sprinterdistans kanske hade varit att föredra så har även hästen kämpat på bra från ledningen över full väg vid flera tillfällen.</li>



<li><strong>Finn Palema</strong> galopperade oväntat utvändigt ledaren efter ett knappt varv på Jägersro. Han gick en bra avslutning gången innan på just Färjestad och Ina Scots Ära-tvåan kommer ta sin första seger på svensk mark när som helst.</li>



<li><strong>Thai M.Square </strong>har radat upp segrar hemma i Norge, men det är inte alltid som de är guld värda när hästarna tas över gränsen och möter såväl bättre toppar som tävlar i jämnare fält. Från spår åtta föreligger därtill en påtaglig vingelrisk och vi har ingen jättekänsla för femåringen även om han varit riktigt bra.</li>
</ul>



<p><strong>Rank:</strong></p>



<p><strong>A: </strong>2 <strong>B: </strong>10-3-5-8-6-1 <strong>C: </strong>7-12-11-9-4</p>



<p><strong>Spetsstriden: Pure Muscle </strong>är klar spetsfavorit och det är verkligen allt som tyder på att den spetsälskande fyraåringen anför fältet.</p>



<p>	
				<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 23 SEPTEMBER								</h3>
														<div class="content">
								
<p><strong>Avd 1: </strong>2,6,7,8,9 (3,12)<br><strong>Avd 2: </strong>1,4,5,7,10 (3,8)<br><strong>Avd 3: </strong>3,6,7 (8,4)<br><strong>Avd 4: </strong>1 Notice&#8217;em (4,7)<br><strong>Avd 5: </strong>1,2,3,4,5,6,7,8,12 (9,10)<br><strong>Avd 6: </strong>2,3,4,6,7,8 (1,9)<br><strong>Avd 7: </strong>2 Lozano di Quattro (10,3)</p>



<p><em>4.050 rader / 2.025 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
